~ Chinese Proverb ~
Piotr BuckiDownload slides
Cross Site Request Forgery (CSRF / XSRF) – jest to jedna z najczęstszych form ataku na strony internetowe. Metoda ta polega na nieświadomym wysłaniu przez użytkownika żądania do serwisu internetowego. Celem atakującego jest wykorzystanie uprawnień ofiary do wykonania operacji w jej imieniu. Osoba o wrogich zamiarach może spowodować wysłanie takiego żądania na wiele różnych sposobów.
Brzmi skomplikowanie? Mnie to nie dotyczy?
Na wykładzie pokaże na czym polega atak CSRF. Następnie pokaże jakie zabezpieczenia (i czy w ogóle) oferują popularne WEBowe frameworki Java.
Odkąd skończyliśmy studia, jesteśmy uczeni aby najpierw przygotować schemat danych, a następnie bazując na nim, stworzyć serwisy odpowiedzialne za logikę biznesową. Jakimś sposobem przekraczając próg pierwszej poważnej pracy zapominamy o zajęciach z Projektowania Obiektowego, gdzie najważniejszy był model. Czas spojrzeć wstecz i przypomnieć sobie o tych zasadach - oczywiście podrasowanych i zahartowanych w ogniu wysoce skalowalnych systemów.
W ramach prezentacji przedstawię na początek klasyczne podejście oparte na anemicznych encjach i serwisach, a następnie rozbuduję je, wprowadzając słuchaczy kolejno w podstawy zagadnienia modelowania złożonych dziedzin biznesowych, podziału modelu według odpowiedzialności, definiowania zdarzeń biznesowych, a na końcu zmiany możliwości persystencji danych. Na każdym stopniu zaprezentuję jak zmienia się model, jakie jego cechy zostają wyeksponowane, oraz na jakich aktywnościach skupia się developer. Ostateczny efekt porównam do pewnych cech języków funkcyjnych.
Poruszone zostaną gorące tematy Domain-Driven Design, Command Query Responsibility Segregation, oraz Event Sourcing'u z akcentem na efektywne połączenie tych technik, oraz wskazaniem jak zmienia się sposób myślenia developera podążającego za tymi wytycznymi.
Poruszane tematy są niezwykle obszerne same w sobie, dlatego głównym celem prezentacji jest wskazanie słuchaczom pewnej ścieżki, którą mogą podążyć, oraz wzbudzenie ich ciekawości i chęci do dalszych poszukiwań.
Wielu z nas staje się liderami z dnia na dzień. Oto z ekspertów technicznych stajemy przed całkowicie odmiennym zadaniem – poprowadzenia zespołu często w niesprzyjających warunkach. Walczymy z klientem, zespołem, ze sobą, z project managerem i wszędzie pojawiają się kłody pod nogami. Jakże tęskno nam zaczyna być do czasów, kiedy tylko programowaliśmy, nie braliśmy pod uwagę kaprysów innych osób i wszystko było pod kontrolą. Tak, to prawda większość z nas nie jest przygotowana do tej drogi. Czasami „musimy”, czasami chcemy, czasami po prostu jakoś tak wyszło. Czasami się frustrujemy, nie wiedząc o co w tym wszystkim chodzi, a czasami cieszymy się jak dzieci, bo naszemu zespołowi się udaje.
Ci wszyscy, którzy tę drogę mają przed sobą, albo są w trakcie, albo ją przebyli i chcą przyjrzeć się z boku temu, co się dzieje, kiedy stajemy się liderami technicznymi, będą mogli przeanalizować główne popełniane grzechy. Usłyszycie kilka historii z życia wziętych i kilka prostych lecz niełatwych heurystyk radzenia sobie z owymi grzechami.
(Polish) Mapowanie relacyjno-obiektowe prawdziwych obiektów - rzecz o obiektach, strukurach, procedurach i funkcjach
Sławek SobótkaDownload slides
Który z trzech sposobów blokowania optymistyczne zastosować? Kiedy używać Lazy Loadingu a kiedy nie? Kiedy używać operacji kaskadowych a kiedy nie? Kiedy encja powinna zawierać w sobie referencję do innej encji a kiedy nie? W których miejscach w systemie stosować JPA a kiedy nie?
Każdy ekspert odpowie na te pytania: ""to zależy"".
Podczas prezentacji będę chciał pokazać Wam, że to wcale nie zależy. Jeżeli modelujesz obiektowo to odpowiedzi są jasne, klarowne i jednoznaczne.
A oprócz tego wrócimy do podstaw (bo podstawy są najtrudniejsze i czas na nie przychodzi dopiero gdy osiągniesz poziom ekspercki) i zastanowimy się kiedy używać obiektów (i zasad CqS, SOLID, GRASP), kiedy struktur danych, kiedy procedur (a'la Turbo Pascal) a kiedy funkcji.
Sławek SobótkaDownload slides
Dlaczego nasz kod na pierwszy rzut oka jest w sumie tak samo czytelny jak karty perforowane wkładane do komputerów Odra? Dlaczego wprowadzenie zmian w 10-letnim kodzie jest tak kosztowne - przecież wszystko powinno być tam już napisane...
Podczas prezentacji zajmiemy się typowymi błędami:
- zbytnie uogólnienie,
- nieodpowiednie abstrakcje,
- oderwanie od kontekstu,
oraz technikami, których możesz jeszcze nie znać:
- modelowanie obiektów poprzez wyłanianie podmiotów, orzeczeń i dopełnień
- modelowanie granic agregatów poprzez ochronę niezmienników
- odwrócenie kolejności: od zachowań do obiektów
- zestaw kilku wzorców i building blocks
po to aby kod pisany w starej poczciwej Javie stał historyjką domenową i był czytelny niczym proza - również dla ekspertów domenowych, umożliwiając stosowanie DDD.
Tom BujokDownload slides
Business project are intensive and tiring. Tight deadlines often make developers produce the infamous "enterprise" code, the quality of which is the least important factor. "We are what we repeatedly do. Excellence, therefore, is not an act, but a habit" Aristotle used to say. Deploying our skills, however, is almost mutually exclusive from mastering them… In this session we will cover 33 things you want to do better, quicker and simpler applying the best of Lombok, Guava, LambdaJ, Mockito, Spock, Byteman, Groovy, Gradle, Logback, Shell and others! Using some real-life examples we will have a peek at the code, analyze the flaw and propose a suitable solution. Not only will we learn how to code better, but also how to raise the bar on a daily basis!
Arun GuptaDownload slides
The Java EE 7 platform has four new components (WebSocket, JSON-P, batch, and concurrency), three that are significantly updated (JAX-RS, JMS, and EL), and several others that bring significant changes to the platform. As you can imagine, a lot of new functionality has been introduced in the platform. In this fast-paced session, you will learn about 50 new features introduced in the Java EE 7 platform. @ClientEndpoint, chunk-style batch processing, @FlowScoped, @AroundConstruct, @JMSDestinationDefinition, and @Transactional are some of features the presentation covers. It explains each feature with a code snippet and provides details on where and how you can use it in your applications.
Today most of us work in Agile/Lean/Scrum/another-cool-word organization. Reasons to create our software this way are many: it is fun, it develops what is needed, it’s competitive and so on…
Even if you don’t Scrum, you definitely do have some experience or, at least theoretical knowledge of it, and decided not to go this way. Again, reasons may be many.
The ultimate goal of all software development process is to create a piece of software that works as intended, is delivered on time with requested quality and within the budget. The way you do it is important, however of a second priority. The most important thing is to choose the way that fits most to your domain, knowledge, maturity and skills of people in the team, process and methodology. The real challenge, in fact, is to boost the team performance and bring it to the next level, despite the process you follow in the organization.
Build a winning culture in your organization.
Culture is what makes an organization ‘the’ organization and can have a great impact on its performance. It is the glue that binds an organization all together. A company may have the greatest product or service, but these can be easily copied. What cannot be is the culture: an unique mixture of company’s values and high performance behaviours which can be a lasting source of competitive advantage.
In my talk, I will tell you what an organization culture is and what are the behaviours that make it winning and high performance.
Matt HarasymczukDownload slides
Agile is not only about Scrum, Kanban or Lean. That is the next project management methodology to revolutionize our development. Agile is a software engineering philosophy. Good practises and care about the quality, the code, that we developers love so much to write. Continuous Integration, Deployment, Delivery, TDD, BDD, Code Review and Pair Programming. Why everybody else forget about it? The talk will be technical, although Scrum Masters and Product Owners will find something for them.
Changing focus from 'code delivery’ and ‘coding velocity', to planned measurable multiple-value delivery for multiple stakeholders.
Agile, as taught and practiced today, is still focused on delivering code: the assumption being that code will deliver value. We believe this is a false idea. First, there are many other ways, than code, to deliver value to stakeholders, like data and motivation. Second code itself is no guarantee of value (for example a 'user time saving'). You have to target the value explicitly, and measure that the user really achieved it.
This talk will explain the difference between our current code focus, and shifting our focus to measurable values of stakeholders. If agile is to survive, then it must get a much better track record of value delivery, or it will be replaced with more useful methods.
I dream of a different world where we measure ourselves on real stakeholder value delivered, not on code turndown charts, and velocity of code production
Learn how to build "heroic" apps with Angular and Dart. Use Dart's structured language and libraries with Angular's components and data binding. See real code and examples that blend the best of Dart and Angular. This session is for any developer that wants to build for the web with productive tools, familiar language, and modern web frameworks.
Everything has gone Cloud but developers haven't yet accepted tools that are hosted there, why is that? What's missing in the available cloud-based tooling environments that makes a developer cringe? What features are in Cloud based tools that developers might not be aware of that can improve their development process. Ken, the lead of the Open Source Orion project, will talk about how Web IDE creators and collaborators are trying to match expectations of desktop developers; what’s available now, and what we’re working on to make a Cloud IDE even more compelling. The talk will cover several Cloud based tools and IDEs, their strengths and weaknesses and even some live development using Orion.
The Eclipse is mainly known as the Integrated Development Environment. However it is also the Rich Client Platform that allows to build the advanced desktop applications.
During the presentation we are going to review the most popular Rich Client Platforms, focusing on Eclipse.
We will also create the sample Eclipse RCP application, using the WindowBuilder plugin and the Nebula Widgets.
OpenStack is a global collaboration of developers and cloud computing technologists producing the ubiquitous open source cloud computing platform for public and private clouds. This presentation will walk you through details behind OpenStack architecture and will also provide hands-on experience in working with this exciting technology.
As more and more people come to depend on their smartphones and the applications written for them, or for the mobile Web, more and more users discover that in the end, sometimes the best experience comes from the most primitive form of communication known to man: the voice. But historically, building an interactive voice (IVR) appliction has been the province of a small number of developers armed with specialized hardware and software. Now, thanks to services that offer "voice in the cloud", developers can offer a new user interface channel to their userbase without requiring a huge investment in technology or learning curve. In fact, using the Tropo service, in this presentation we will do exactly that: build a voice (and SMS) channel that anybody in the room can call. Just for fun.
Java bytecode is the code set used by the Java runtime (the JVM) that is JIT-compiled into native code at runtime. Find out how to read (and write) JVM bytecode directly, so as to better understand how the runtime works, and be able to disassemble key libraries that you depend on. We?ll even take a look at the new bytecode instructions being debated for introduction in Java 7, and how they might behave and operate. We'll also tackle examining tools and libraries that can be used to manipulate Java bytecode directly, such as Javassist, ASM and BCEL, and why and when you might do this.
W prezentacji pokażę praktyczne metody poprawy czasu ładowania webaplikacji zarówno w wydaniu full site, jak i mobile. Omówię proces ładowania różnych zasobów w przeglądarce. Opiszę jak organizować zasoby na stronie, aby ładowały się szybciej. Opowiem o ograniczeniach protokołu HTTP jak i niższej warstwy TCP i jak sobie z nimi radzić. Pokażę z jakich narzędzi korzystać do weryfikacji wydajności webaplikacji po stronie przeglądarki.
Netty 4 is the newest version of the asynchronous framework that powers Akka, Elasticsearch, Finagle, JBoss, Play, Storm, and numerous other high-performance projects. Perhaps you want to write such apps. But Netty’s APIs require some effort to understand. Even with provided sample code and docs, it's not immediately clear how to construct Netty channel pipelines, or what methods are invoked in Netty handlers as network events occur.
To slice through this complexity, Jython’s socket-reboot project offers a Rosetta Stone for understanding Netty. Jython uses Netty to implement C socket semantics on top of the underlying Java NIO support. This means being able to support such semantics as switching from blocking mode to nonblocking mode, and back, at any time, while support selection regardless of mode. But such mode switching only requires 12 lines of code. Selector support only requires 10 lines. And so forth. Just like if you were trying to initially understand a foreign language you might turn to a dictionary or a phrase book instead of a novel, using a translation between C and Java like socket-reboot can give you better insight for what your own app needs.
World is using Hadoop Map Reduce to perform large scale computing tasks. Does it fit every possible situation? When it's not optimal, and what are the approaches to overcome those problems? Short introduction on idea behind Sparc data processor and Shark query engine. Architecture overview, pros and cons. How the solution fits into existing systems. What are the benefits - is it worth trying and when? Limitations. Few code examples explained.
Invoke dynamic is a Java 7 feature that had the most impact at the bytecode level and also in terms of performance. First perceived as a feature to help dynamically typed languages on the JVM, it turned into a powerful feature that has been exploited quite a bit in the implementation of features in the Java language itself. In this presentation we will understand what problem this features really solves and how it has influenced other features in the Java language and on the Java platform.
I was very disappointed when the Discovery Channel cancelled "Dirty Jobs" without dedicating an episode to "Debugging", a job many consider far more disgusting than that of the "Geoduck Harvester or the "Turkey Inseminator". For the unfamiliar, the show features Mike Rowe performing difficult and stomach-turning occupational duties of some of the messiest jobs in America. I have yet to meet a software engineer who jumps out his or her chair in excitement at the thought of fixing one of his or her bugs let alone other people's. It can be one frustrating of a task, and sometimes "twice as hard as writing a program in the first place" in the words of Brian Kernighan who needs no introduction. In this session, you will be exposed to a more systematic and rigorous approach to debugging, and will be introduced to a number of techniques and methods inspired by modern studies in cognitive psychology, the philosophy of science, and other fields. A survey of the available tooling will also be conducted. Come to the session to join the coalition forces on the war on bugs. You never know, you might end up changing your mind about your favorite part of being a software engineer after all.
Jarek RatajskiDownload slides
Have you ever been in a project where doing Web front coding was a worst possible
engagement in a team?
We Java developers can do really great code ,we do tdd, clean code, reviews, static analysis etc.. Well, mostly as long as we talk about the Java part that is working on the server side.
When it comes to a GUI things are slightly different. We tend to create lot of JS, CSS,HTML having no real clue what is going on. Copying and pasting code that we got from Web Designers. Eextending it with some random snippets we find in Internet. And then we get the mess? And we make it public.
In the talk there will be shown some common problems for Java developers that are associated with web development. There will be also proposed solutions, rules and tools that can help in overcoming pitfalls. Surprisingly? the most important rule is that once You do web development - you have to make it exactly as serious as any other development !!!
Whole presentation is done as a Web page in HTML5/CSS3 with lot of nice features that show themselves power and possibilities of modern Web applications.
Web show -live coding
This session will present the most important new stuff in Java™ 8. It will show how to get started developing Java™ 8 code with Eclipse and then demo the new features that are available in Eclipse for this new Java™ release. We will also look behind the curtain and see how the JDT team accomplished that great piece of work.
Włodek KrakowskiDownload slides
Balance - this is the word we can hear in lots of places but not too often in software development. But what balance can you talk about in our industry? What is the balance we need/ How can we achieve it? Marketing people needs to have a product they can sell, developers needs to have a product that is easy and nice to work with.
How can we take care of this balance? Who should take care of it? Can developers only complain “if only I had more time I would write unit tests… / I would take care of the design / the code would be in better shape...”? Did you hear such complaints next to your desk? So what can we do about the above? It is enough to be a good developer or do we need something more?
In my talk I would like to talk about Effective Refactoring.Effective Refactoring joins two things : refactoring and effectiveness. Refactoring is a means to achieve the balance between production (clients receives working product) and production capability (developers are able to extend the product and deliver new functionality). Effectiveness is the mental approach to achieving our goals. Only when you join them you can act reasonably.
My goal is to encourage people to change the approach to work by refactoring when needed, by making it everyday practise or a habit. Each of us want to be happy at work. We want to be motivated but do we take care of it? We want to have good quality code, covered by tests, object oriented but what we really do to achieve it?
I would like to show 7 Habits of Highly Effective People presented by Stephen Covey in his best seller and how they can be applied to software engineering. Here are they.
Are you waiting for things to be done and complaining? Are you part of the solution or part of the problem? “It’s not me - it’s the team”. Did you hear this complaint?
Start with end in mind
Do you ask yourself questions : what I am doing? how should I do this? why I am doing it this way? What will be the outcome of my decisions in the near future? Did I really saved time if I skipped refactoring and quality although the product “is working”?
Importance before urgency
Certainly sometimes we need to put off the fire at work. But what kind of a motivator it is? “Must do it” vs “want do it” are two different approaches and if you want to use the latter approach you need to to really proactive and minimize the number of fires. Then you will have more freedom to take care of your code.
Think Win - Win or No Deal
What is your approach to collaborators? Do you perceive your (product) managers / marketing as competitors (time vs quality) or members of one team that drives together towards the success?
Understand before being understood
How to approach dealing with legacy code? Do you just add you new functionality or consider refactoring before or after this? What you do before you decide to improve the design? Do you want to understand the current state before proposing / imposing your changes?
Do you understand the difference between compromise and synergy when two people have different opinions and want to achieve agreement? Team can benefit a lot if people are looking together for “third solutions” instead of competing.
Sharpen the Saw
Do you take care of yourself so you are able to make it better? Do you know the areas of yourself to grow (physical, mental, emotional, spiritual dimensions). Do you know that sometimes to be better in refactoring is to stop refactoring?
Kito MannDownload slides
One of the most common reasons for software defects is poor exception handling. The more complex the application, the more difficult it can be to track down the root cause of a bug. An exception at the service or database layer may manifest itself as unpredictable behavior at the user interface level. Simple coding errors or unexpected inputs may result in unnecessary and confusing error messages. The net result is an application that doesn't meet the user's expectations.
These types issues can be avoided by handling exceptions properly. In this session, we'll look at examples of what happens when exceptions aren't handled, and how you can avoid unexpected defects by following a few key principles and using some discipline. We'll also examine the importance of establishing logging standards, and look at how to properly configure error pages and use the error handling facilities in JSF and Java EE applications.
Stefan ZeigerDownload slides
Slick is an open source Functional Relational Mapping library for Scala that enables queries to be built in a functional way. With Slick queries are type-safe, composable, and fit better with the relational model. This session will cover the benefits of FRM over ORM and the basics of Slick.
When searching on Google with the keywords “Gerrit” and “GitHub” you find lots of different links with more questions than answers; see below a selection of the most interesting ones:
- Stackoverflow.com – Gerrit with GitHub
- Stackexchange.com – Pros and Cons of Code Review vs. Pull Requests
- Julien Danjou - Rant about Github pull-request
- CloudFoundry.org – Gerrit and Jenkins workflow with GitHub
- Gerrit, GitHub, GitLab comparison on YouTube
- DZone – GitHub: more on how free sucks
We present out experience (and lessons learned) of integrating Gerrit with GitHub trough replication and OAuth SSO using the GitHub plugin for Gerrit Code Review.
Lukas EderDownload slides
SQL is a powerful and highly expressive language for queries against relational databases. SQL is established, standardised and hardly challenged by alternative querying languages. Nonetheless, in the Java ecosystem, there had been few relevant steps forward since JDBC to better integrate SQL into Java. All attention was given to object-relational mapping and language abstractions on a higher level, such as OQL, HQL, JPQL, CriteriaQuery. In the mean time, these abstractions have become almost as complex as SQL itself, regardless of the headaches they're giving to DBAs who can no longer patch the generated SQL.
jOOQ is a dual-licensed Open Source product filling this gap. It implements SQL itself as an internal domain-specific language in Java, allowing for the typesafe construction and execution of SQL statements of arbitrary complexity. This includes nested selects, derived tables, joins, semi-joins, anti-joins, self-joins, aliasing, as well as many vendor-specific extensions such as stored procedures, arrays, user-defined types, recursive SQL, grouping sets, pivot tables, window functions and many other OLAP features. jOOQ also includes a source code generator allowing you to compile queries in modern IDEs such as Eclipse very efficiently.
jOOQ is a good choice in a Java application where SQL and the specific relational database are important. It is an alternative when JPA / Hibernate abstract too much, JDBC too little. It shows, how a modern domain-specific language can greatly increase developer productivity, internalising SQL into Java
Roland KuhnDownload slides
The game has changed: we write interactive web applications, we distribute the processing of huge data sets and our services need to be available at all times. This new breed of applications comes with its own set of requirements and forces us to establish new blueprints for designing our systems. In this talk we ask the crucial questions along this path, show which answers work and which don’t, and distill the essence of the common theme—Going Reactive.
Programmers, architects, CIO/CTOs and everyone with a desire to challenge the status quo and expand their horizons on how to tackle the current and future challenges in the computing industry.
Java 8’s lambdas make building Reactive applications a whole lot easier and cleaner. Through copious code examples this session will show you how to build event-driven, scalable, resilient, and responsive applications with Java 8, Play Framework and Akka. On the web side you will learn about using lambdas for async & non-blocking requests & WebSockets. You will also learn how the actor model in Akka pairs well with lambdas to create an event-driven foundation that provides concurrency, clustering and fault-tolerance.
This talk will give the audience an introduction into Hazelcast, the open source in-memory data grid.
Hazelcast helps developers and vendors to scale in and out on data and data processing as well as scaling their applications itself.
The talk is filled with some smaller demos and some short live codings. It will show basic features, how easy it can be to work on cluster environments and how Hazelcast can help on scaling your data and applications.
Vert.x is a lightweight, high performance, reactive application platform for the JVM that’s designed for modern mobile, web, and enterprise applications. In this talk you will learn about the design principles and motivation behind Vert.x and why we are heading for a reactive future.
You’ll also learn about how improved build tool and IDE integration simplify the process of developing applications with Vert.x – including short demonstrations of module auto-redeploy from the IDE and executable “fat jars”
Kai GilbDownload slides
...and how to prioritize to deliver it.
Success is usually defined well at the financial level. At the level of the Stakeholders, your Software Product , not so. To be part of a team delivering success with software we must know what success looks like, not only at the financial level, but at the direct technical level you are working with. For example with regard to usability and security.
Hint: user stories and burn down charts do not do the job either.
Tips: You will learn practical principles and ideas, gathered from years of experience on focusing product development towards creating success. When people at all levels know how to define success at their level, and all levels support each other, something remarkable happens. Kai Gilb will illustrate the theory real Case studies and examples.
Scala brings a ton of useful language constructs that even very experienced programmers might find mind-bending (unless the programmer was careful not to tie his thinking to a single programming language). Scala is a object-oriented-functional hybrid language with its own semantic. Knowing it surely makes you a more proficient programmer and for Java ones might be a useful way-out to functional programming world. Come and see Scala by examples that let you get started with the language and apply it to your projects. A mixture of slides with theory and code should be enough to wet your appetite for more.
Ben LavenderDownload slides
Test all you want: big changes are dangerous, except when they're small.
In this talk, we'll cover specific integrations and APIs you can use to automate your workflow. We'll include both tools and practices required to keep shipping small changes quickly, shipping safely, and shipping quality.
We all know we should write tests and constantly improve quality by inspecting the code. What we don't want to admit (at least out loud) this is often a dull task. During this talk you'll be introduced to a few Eclipse plugins and techniques that will make the experience a bit more pleasant. You'll learn how to make sure each class is tested and how well covered it is with the tests. After the talk, you'll know how to create a missing test with just a few clicks and that includes mock testing. All of this will help you improve quality of your code, making you focus on adding new features and not chasing those pesky bugs over and over again. All tools presented are free and being used in the field. No product selling, just pure pragmatism.
Java App deployment is a complex and time-consuming process requiring OS installers, package management tools, configuration management tools, configuration recipes, install scripts, deployment scripts, server tuning, server hardening and more. Is this necessary? Are we trapped in a mindset of doing it this way just because we've always done it this way?
What if you could radically simplify all this? What if entire machines could be generated in seconds with a single command? What if you could run the same machine unchanged on your workstation and in the cloud?
This talk challenges the status quo and proposes a radical rethinking of Java App deployment. If you believe in simplicity and efficiency over complexity and brute force; if you aren't afraid to look forward with fresh thinking, then this talk is for you. Live demo included.
This session will show the current state of JavaFX on different platforms like Desktop, Raspberry Pi, Android and iOS. The session will be based on a demo that uses the same code and runs on all the mentioned platforms. It will be explained what you have to take care about and what is possible today using JavaFX on different platforms.
Kito MannDownload slides
Dart, CoffeScript, and TypeScript.
So much of the time we focus on what we do and how we do it.
We read books on coding, we come to conferences, we download open source and sample code, we read blogs and listen to podcasts.
During this session we'll explore why we do what we do and for whom. Whether you're inspired or depressed by this talk, you will think differently the next time you open Xcode and type Command-Shift-N and you'll pause before you upload your next app to the app store. Uploading is when you sign your name on your work.
2014 marks the tenth year since the creation of the Eclipse Foundation. Eclipse has enjoyed years of great community, great technology and significant impact in the software industry. Eclipse has also evolved from being the Java IDE to being a community of open source projects that span a wide variety of industries and technologies. As we head into our next decade it is time to reflect on what is the potential for the Eclipse community.
This keynote presentation by Mike Milinkovich, the Executive Director of the Eclipse Foundation, will explore what are the possibilities for Eclipse in the next 10 years. Let’s start a conversation on how the Eclipse community needs to change and grow to take on new challenges and achieve even greater success and impact in the next 10 years.
Denise JacobsDownload slides
As tech industry professionals, you need ways to work better so that you can create more, but what do you do when you hit a seemingly insurmountable mental wall? You need to get unblocked: to bust through that barrier to allow creativity to flow. Combining the neuroscience of creativity, productivity techniques, emerging practices that spur innovation and synergistic collaboration, we'll discover techniques and tools to get past those mental barriers that keep you stuck (or at least slow you down). We'll further uncover the ways in which our brains work best creatively: what’s behind the times when we feel on fire with ideas and inspiration…and when we don't. These processes and techniques will not only enhance creative productivity, but they will also have you operating from a place of passion and excitement. Beware: this session challenges the standard norms around concentration, focus, productivity, and may change how you work…for the better.
You're a manager. You've been hired to run a small (or large) development team, and for the life of you, you can't understand these people. Every time you try to motivate them, they balk and resist. You try to hire them, you can't figure out what they want and they walk away. Then, without any sort of action on your part, suddenly they put in 16-hour days, and they pull off some amazing work, but when you try to ask them to do it again for a critical update, they get angry and quit. What the heck? Where did these bizarre alien creatures come from, and how in the world are you supposed to work with them?
You're a developer. You work for what has to be the most clueless manager in history. For the life of you, you can't understand this guy. He keeps trying to "motivate" you when all you want is for him to get out of the way. He's ready to drop thousands (or millions) of dollars on a release party, but getting him to pony up some cash for a conference or training class is like wringing blood from a rock. What the heck? Where did this bizarre alien creatre come from, and how in the world are you supposed to work with him?
Delegation of power to programmers is a smart idea. It is provably and measurably smarter than leaving the power with managers to design the developer’s work environment, and with IT architects to design the technology that we should program.
Devolving the power to create a better working-environment, and to design the technology for our stakeholders, is better because developers are closer to the action, are more informed in practical detail and they can rapidly and frequently, test and measure, that their ideas really work.
It's been around for a long time, but everyone's talking about it all of a sudden. But why and why now? We've been programming in languages like Java for a while, quite well. Now we're asked to change and the languages themselves are changing towards this style of programming. In this keynote, a passionate polyglot programmer and author of "Functional Programming in Java: Harnessing the Power of Java 8 Lambda Expressions" will share the reasons we need to make the paradigm shift and the pure joy—the benefits—we will reap from it.
Mary PoppendieckDownload slides
Have you ever worked on software that disappointed customers? That created problems when it was used? That was never used? Success has many parents, but failure is always an orphan.
It’s time for developers to take responsibility, along with their teammates, for delivering something that really solves problems for customers. They should not assume that just because someone tells them to do something, it is the right to do. They must be responsible for assuring that what they develop is the right thing to develop.
This talk is about how shared responsibility, short feedback loops, and the shadow of the future make everyone a parent when it comes to developing complex software systems.
Volodymyr FedakDownload slides
Refactoring in the Large Software projects is a complex and challenging task that is very difficult to accomplish without mistakes. In this presentation I would like to share experience how to successfully execute complex restructurings, the main rules and common pitfalls for performing such refactorings.
All these rules have been gathered based on previous experience and several examples of such refactorings and potential issues will be demonstrated.
Krzysztof DębskiDownload slides
Microservices everywhere I see. Create and deploy them fast you should. But how to prepare a system that might be affected by scalability issues everywhere? Even in a simplest component. You might build your own framework, but probably you will finish with the abandoned project. Therefore instead of writing from the scratch, we've gathered all cool stuff from open source project to create bootstrap. We wanted to let our developers create scalable services really fast. In a talk I would like to focus with you about all the choices we made, we will discuss about all the ecosystem we built over services.
It is not only about the code we write, but all the tools that make our life easier.
If you want to start working with services or upgrade your service environment it is the best place to start.
In the world of multi-core programming, traditional parallel programming techniques with locks (mutexes and similar mechanisms) create performance bottlenecks. Lockless programming is a set of techniques employing atomic operations to synchronize data exchange between threads. The talk introduces the audience to the lockless programming, presents its benefits and pitfalls. The presenter will talk about support for atomic operations in different CPU families as well as support for them in lower- and higher-level languages. He will also cover reordering and memory barriers. He will end the talk with tips on designing lockless algorithms and practical examples of lockless data structures.
Jakub MarchwickiDownload slides
“Micro Service Architecture is an architectural concept that aims to decouple a solution by decomposing functionality into discrete services. Think of it as applying many of the principles of SOLID at an architectural level, instead of classes you've got services”. Acknowledge that and endless possibilities start to open.
In this talk I’ll walk through several scenarios, where the microservice approach worked for us: from green field solutions, to handling legacy systems. The microservices in various aspects: duplicating functionality, proxing existing applications, bubbling new services on the top of existing big bull of mad. The microservice approach solving some painful problems become much easier, without “we need to rebuild it, redesign it” cliché. It appeared possibilities were endless: wrapping existing monolithic PHP application as a microservice in another PHP application, building a bubble on top of existing PHP code with dropwizard and AngularJS, wrapping some legacy ActiveX components with python Win32 extensions. All with one common denominator: HTTP as the basic dialect.
Today's applications are systems, not large applications. They consist of smaller, singly-focused services, usually connected over REST. To achieve maximum velocity, services today are continuously deployed and integrated. Services need to slot into the system with ease, they need to be secure, and they need to be open, transparent. In this talk,
join Spring Developer Advocate Josh Long (http://twitter.com/starbuxman) for a look at how to build smart, REST and hypermedia-ready, OAuth-secured microservices with Spring Boot.
Tugdual GrallDownload slides
MongoDB's basic unit of storage is a document. Documents can represent rich, schema-free data structures, meaning that we have several viable alternatives to the normalized, relational model. In this talk, we'll discuss the tradeoff of various data modeling strategies in MongoDB using a library as a sample application. You will learn how to work with documents, evolve your schema, and common schema design patterns.
Last week Apple introduced Swift - a new programming language for developing iOS and OS X apps that. Traditionally, developers have used Objective-C. Java occupies an interesting place between Objective-C and Swift. Objective-C famously had a big influence on Java. You can see the influence of Java (and other JVM languages) on Swift.
In this talk we'll look at the similarities and differences between the three languages. In the first half you'll encounter the square brackets and colons that make it easy to identify Objective-C. We'll look at header files and other common patterns of Objective-C. In particular, I'll try to explain the reason why we do things differently in Objective-C than we do in Java and I'll introduce you to some of the fundamental Cocoa patterns.
The Swift programming language was only revealed last week. We haven't learned the best practice patterns yet. In the second half of the talk I'll introduce you to the syntax and fundamentals of Swift. You'll see that it is different from Java in fundamental ways but very accessible for a Java developer.
It is well known that applying coding conventions, specially in long projects, simplifies the project maintenance. Indeed, Sun Microsystems said 40%-80% of the lifetime cost of a piece of software goes to maintenance.
With the current QA tools, such as PMD or FindBugs, we can detect automatically which files of our code do not follow a list of our own coding conventions. In this way, we can get a list of which files are violating a convention. But who will always fix the code? Ourself.
That's the reason why we have been build Walkmod (http://www.walkmod.com); an open source tool to automatically apply and share coding conventions in a software project. For example, having a license header in all source files, applying an specific design pattern are common tasks which are easy to do with Walkmod.
In this session, the presenter will cover all main aspects of walkmod, how attendees can design their own coding conventions.
Bottom-up or top-down, emerging design, TOGAF, UML, BPMN, SOA, large scale, small scale, new shiny written by hipsters or good old legacy written by Iron Maiden fans?
How to build architecture of your system? How to transition your current design and don't get mad, don't waste time for
unproductive meetings, discussion, arguments and cheap talks, writing down business cases, searching for business value and justifying business justification.
After years of small and large projects, waterfall, Agile, Kanban, couple of paradigm shifts, couple of trend explosions, new and shiny tools and techniques. After all this I understood that whatever we want to believe it or not, we don't deliver code, business value or company success.
The only thing we do is we increase entropy of this world, by adding more and more complexity, that no matter how fast CPU executes our code, how much time and effort we put in quality, at the end of day each software will be destroyed by its complexity. Maybe ""Software is eating the world"", but for sure complexity swallows the software at the same time.
During this talk I would like to share with you a few patterns I have discovered, learned and stole over the years, a couple of obvious, well known tips&tricks, which we tend to forget about, so I gave them a name to make it easier to remember about them. I called them Patterns of Organic Architecture.
Why? Because the only thing that seems to be able to cope with complexity is nature. Nature doesn't plan, doesn't use advanced frameworks, doesn't have deadlines, meeting, memos and such. And still we discover more and more beautiful works of nature which amaze us with its simplicity.
This talk will prove that if you learn how nature works, how much you can learn exploring pyramids and that some of the systems have strange attractors, you will not need software enterprise principal architect on your team, because he will never ever again leave his ivory tower.
You will learn how to grow your system!
Kito MannDownload slides
PrimeFaces continues to be the most popular UI component suite for building web applications using JSF and Java EE. Built on top of jQuery, the open source suite features over 100 components with powerful client-side and server-side functionality, as well as seamless integration with Java back-ends. Coupled with HTML5, Ajax Push powered by Atmosphere, mobile support, and customizable themes, PrimeFaces is a great way to build modern web applications. This session covers the core PrimeFaces components as well as the key new features in PrimeFaces 5.
When you start using Cloud in your organization, it is natural, to make it in an evolutionary way - as it helps in initial adoption. But soon you will realize, that cloud is offering much more opportunities - if you could only change your way of thinking... To fully unleash power of Cloud based solutions, dramatic change of thinking is required. There are still much more questions than answers, new challenges added to existing ones - but Cloud is giving opportunity to deal with them in a different way.
The reactive manifesto movement promotes architecture that lets developers build applications to satisfy today’s demands of scalable, resilient and readily responsive websites and services. The cornerstone of such systems is their event driven nature. Rx java provides an interface that abstracts event delivery. It is aimed at simplifying server-side concurrency. With a set of functional operators for filtering, grouping, transforming and combining event streams Rx Java gives you powerful tools to create event driven systems. I will show you how to use this library on client and server side, how it influences application design and why this approach is superior to using futures and callbacks. I will present lessons we learned when using Rx Java in our production services; we will take a closer look at its performance characteristics and limitations. I will also show how one can use this approach to get rid of listeners and observers when interacting with various event producers (such as UI).
Daniel DeogunDownload slides
When mentioning Akka, most of us think of a framework allowing one to design high performant, scalable, and fault tolerant systems. But the question is, how can one utilize the power of reactive programming when surrounded by legacy?
In this talk, we will share our insights and experiences from developing high performance systems with Akka. Despite that Akka APIs are more favorable in Scala, we have chosen and successfully used Akka’s Java APIs. A strategy that may have significant impact on the business and the success of a project. In addition, we will present how domain specific requirements influences your design options, the traps we have walked into, and how everyone may benefit from Akka regardless of green or brown field development.
The world of frameworks became a pretty dangerous jungle nowadays. Swamped in dependencies, forced to bend your architecture to their needs, you find yourself shaving yaks and tackling accidental complexity. Hidden magic makes it even worse, setting up traps everywhere you step. In an ideal world you would like to express all your needs in code - thats what we love, don’t we?
Dropwizard brings some sanity to this madness. It’s a production ready mix of Jetty, Jersey, Jackson, Metrics, Guava, Logback and nothing more. A perfect match for microservices based architecture.
In this talk we will ride through Drowizard’s features and confront them with my experiences from Schibsted. I’ll pay special attention to:
- embedded containers and how they decrease the gap between dev and prod
- DIY DI and how to live in a world not infected by IoC containers
- metrics and how to get service health on a grasp
Skinny modules, design by contract without a contract, proliferation of deployment packages are examples of a typical enterprise cargo cult disease. In this session I would like to discuss a "perfect" Java EE 7 architecture and focus on the modularization, interaction and architectural aspects of Java EE 7. Warning: this time I will use some slides. This session is planned to be interactive -- disrupting questions are highly appreciated.
Simon RitterDownload slides
The significant new language feature in Java SE 8 is the introduction of Lambda expressions, a way of defining and using anonymous functions. On its own this provides a great way to simplify situations where we would typically use an anonymous inner class today. However, Java SE 8 also introduces a range of new classes in the standard libraries that are designed specifically to take advantage of Lambdas. These are primarily included in two new packages: java.util.stream and java.util.function.
After a brief discussion of the syntax and use of Lambda expressions this session will focus on how to use Streams to greatly simplify the way bulk and aggregate operations are handled in Java. We will look at examples of how a more functional approach can be taken in Java using sources, intermediate operations and terminators. We will also discuss how this can lead to improvements in performance for many operations through the lazy evaluation of Streams and how code can easily be made parallel by changing the way the Stream is created.
Tomasz NurkiewiczDownload slides
OLAP is not new but until recently was reserved for Big Companies and huge servers. In the age of NoSQL, data scientists and Hadoop we will look at Saiku and Mondrian – open source online analytical processing server. It turns out we can easily implement fascinating interactive reports and charts using familiar relational databases. Aggregation, filtering and visualization was never simpler. No more handcrafted reports and impatient customers.
During this session we will learn how to build simple yet powerful data warehouse from real life sample – and with real life experience. Thus we will focus on data loading process, optimizing and customizing the engine. I have a feeling that most of you will leave the room with a desire to build their very own data warehouse right away.
To get the most out of Specification by Example (SBE), Behaviour Driven Development (BDD) or Acceptance Test-Driven Development (ATDD), you need much more than the right tools. You need high value specifications. How do we get the most out of our specification and test writing effort? How do we turn vague business-speak into testable scenarios? How do we express good acceptance tests that are both readable and automated? How do we distinguish between Stories, Specifications and Scenarios? These and other questions will be addressed in this talk in which we take a practical approach using real-world examples.
If you work with Cucumber, Fitnesse, SpecFlow or similar tools to support BDD and SBE, you will learn how to avoid common mistakes that teams make when writing tests. You will also learn to recognise the characteristics that take good example scenarios beyond the role of acceptance tests and into living documentation for long-term value.”
I have never given this talk before in any conference. It iEnforcing the cloud presence of an organization by exposing a RESTfull API is of extreme importance. It is a demanding and formidable task that can turn out to be either a great asset or a dire liability. This challenge is amplified by the vagueness of what a REST architecture is, and the diversity in approaches and opinions among the leading Web APIs.
This session attempts a balance between the spirit and philosophy behind REST, and the practicality and elegance inspired by the principles of modern API design. This very idea is highlighted through a series of concrete issues that frequently surface while building or evolving a mature REST interface whose goal is not only to be complete and feature-rich, but also intuitive and practical.
Wojciech SeligaDownload slides
Many companies from software industry deal with the problem of maintaining its innovative character over the course of time, especially after achieving bigger size and the maturity. Innovation is difficult (or impossible) to measure and calculate its ROI. However losing innovation means sooner or later the end of the business.
So some of the big bosses of big corporations even cry - “Innovation happens elsewhere” - or simply conclude that maintaining innovation is only possible via ongoing acquisitions of smaller, still innovative companies. We witness it very frequently.
Wojtek will share his insights about which values, rules and practices one can foster or apply in a software company (of any size) to let its employees implement their most ambitious and crazy dreams which is the key to the innovation.
When the Spring Framework saw the light of day, it was a real revolution in comparison to the Java Enterprise Edition. However, in recent years the former has been growing and the letter has been adding more and more default functionalities causing the distinction between them is blurred.
Fortunately in recent months Spring Boot has appeared on the market, which is a milestone in the process of the further simplification of application development. Mechanisms such as autoconfiguration or integrated application server again made the takeover of the market complete and left the competition far behind.
During this presentation Jakub will briefly describe the main features of this product, and we will learn about its basic elements. We will also see how it can be used in existing applications based on Spring.
iOS developers use visual tools for creating the visual aspects of our applications. In this whirlwind tour, you'll see how we use storyboards to create flexible interfaces for both iPhone and iPad. We'll connect our GUI to code and build transitions to segue from one scene to another. We'll use autolayout so that our UI can adjust to screens with different dimensions and localize our content to support different languages. You'll see the code that supports the storyboard but we'll focus on the visual aspects of our apps.
Everyone knows about TDD nowadays, but do you feel you are spending more time testing than writing code ? Where is the point where tests become an impediment to the evolution of your project ?
Instead of taking a religious approach to TDD (""you MUST ..."", ""good developers DO ...."", ""have you read the book XYZ on ..."") this talk is more for looking at where we are and what the TDD-mania has lead projects to.
Mockist TDD has lead software to a even higher level of complexity, up to the point where looking at the tests lead to a much higher confusion rather than just reading the code.
We will go through the TDD-related problem and real-life experiences in a very interactive talk, with a common goal to see what we can do now to make our tests more a tool for a better code rather than a karma for our development working life.
You spend your precious time building the perfect application. You do everything right. You carefully craft every piece of code and rigorously follow the best practices and design patterns, you apply the most successful methodologies software engineering has to offer with discipline, and you pay attention to the most minuscule of details to produce the best user experience possible. It all pays off eventually, and you end up with a beautiful code base that is not only reliable but also performs well. You proudly watch your baby grow, as new users come in bringing more traffic your way and craving new features. You keep them happy and they keep coming back. One morning, you wake up to servers crashing under load, and data stores failing to keep up with all the demand. You panic. You throw in more hardware and try optimize, but the hungry crowd that was once your happy user base catches up to you. Your success is slipping through your fingers. You find yourself stuck between having to rewrite the whole application and a hard place. It's frustrating, dreadful, and painful to say the least. Don't be that guy! Save your soul before it's too late, and come to learn how to build, deploy, and maintain enterprise-grade Java applications that scale from day one.
Topics covered include: parallelism, load distribution, state management, caching, big data, asynchronous processing, and static content delivery. Leveraging cloud computing, scaling teams and DevOps will also be discuss. P.S. This session is more technical than you might think.
Paweł BadeńskiDownload slides
We have TDD, BDD, CI, CD, cloud, and REST - it was supposed to be all great, ended up being ""as usual"". We forgot about ""your code is not clean"", ""people on the team think you’re really arrogant"", ""I don't want to work here"". In this presentation I will talk about:
- how to effectively give suggestions to others,
- the challenges you come across when giving feedback,
- patterns useful for receiving feedback effectively,
- and many other concepts, which make it easier to use feedback on your team.
Michał GrucaDownload slides
During the course of this talk we're going to take a deep dive into what allows developers to be successful. We're going to start our journey from basics of how to be productive and stay in the zone, and will end up on checking out what tools are out there available to help us to achieve that goal.
Mary PoppendieckDownload slides
If you think that agile software development is about short iterations and standup meetings – think again. The technical heart of agile is the ability to develop Known Good Stuff. That means that you know at any time that what has been done so far actually works – and will continue to work correctly all the way through integration, acceptance testing, and in actual use. By taming the integration monster you tame the complexity monster as well.
At the heart of successful agile development, we always find short end-to-end feedback loops that guarantee quality and fitness-for-use as code is being written. It is wasteful and irresponsible to develop software with hidden defects that will only show themselves later, or with features that are useless – or worse, annoying – for customers.
This talk is about Continuous Delivery: what it means, what it takes to make it work, and why it is essential to good software engineering today – even, or especially, for large systems. It covers a lot of ground, from automation and aggressive testing to DevOps and deployment strategies.
Some companies prefer to work in waterfall. Some are truly Agile. Majority does both - they pretend to be Agile, but they work in old-fashioned way. So what is Agile? What does it mean to be an Agile company? We will explore this matter based on examples from IT industry trying to address large corporations, but also the phenomenon of start-ups.
Having built Evernote apps for several wearable devices, including the Samsung Galaxy Gear and the Pebble Smartwatch, Damian will take you through the behind-the-scenes journey of building these apps, from deciding what functionality to expose to the technical details of how he built them and why.
Damian will also cover the latest developments in wearable app development, with code examples covering the major wearable vendors.
Leif ÅstrandDownload slides
"Do you know what CSRF is? Or what direct object reference vulnerability means? If not, then your application might have a serious security vulnerability.
Frameworks like GWT and Vaadin take care of some aspects of information security on the developers’ behalf whereas other aspects are still up to the developer to get right. This presentation walks through the OWASP Top 10 list of typical security flaws and investigates how they relate to applications developed using GWT or Vaadin. The goals of the presentation is to show how a mature framework can improve security and to make developers aware of aspects that they still need to handle themselves. The talk will give you insights regarding your own web application security regardless of if you are using GWT, Vaadin or any other framework. Beginner or Intermediate level."
WildFly 8 (née JBoss Application Server) is Red Hat's open source Java EE 7 compliant application server. It contains robust implementations of WebSocket, Batch, JSON, Concurrency, JMS2, JAX-RS 2, CDI 1.1, and all Java EE 7 technologies. Undertow is the new cutting-edge web server in WildFly 8 and is designed for maximum throughput and scalability, including environments with over a million connections. The number of ports is reduced by multiplexing protocols over HTTP using HTTP Upgrade. Role Based Access Control support organizations with separated management responsibilities and restrictions. Roles represent different sets of permissions such as runtime operation execution, configuration areas that can read or written, and the ability to audit changes and manage users. In addition a new restricted audit log can be enabled including the ability to offload to a secure syslog server. It also provides a rich web-based administration console and a powerful CLI for management. Multi instance cluster with high availability can be easily created. You don't even need to download WildFly in order to experience this functionality. Applications can be directly deployed to OpenShift, Red Hat's open source PaaS offering. This session will provide an overview of all these features using several live demos.
When a code-base grows beyond a certain size, any original arrangement of source files (or architecture) is often lost. The developers also become lost, and start drowning in the ever-expanding sea of classes.
Usually the underlying code – the classes – are in reasonable shape. The problem is that there are too many classes to understand without any higher-level guiding structure, and physical structures (such as packages or jars) have become a tangled mess.
The good news is that it is generally perfectly feasible to organize existing classes into a modular hierarchy with minimal impact on the implemented code. This is far less expensive than starting over, and more likely to succeed! A code-base with a clearly communicated, cogent architecture is much more valuable than a Big Ball of Mud, and developers will love the result.
The process of architecture discovery/development requires the use of “code-first” modeling tools such as Structure101, Lattix, SonarGraph, etc., which parse the as-is code and capture the containment and dependency structures. This model can be manipulated to organize classes into a new containment hierarchy by reusing useful aspects of the existing physical structures, and/or assembling together cohesive clusters of classes from the bottom-up.
Once a measurably well-structured containment model is in place, the allowable visibility and dependencies between groups of classes can be defined, and the code refactored as needed to make it conform. The alignment of the physical structures can follow once the implementation-level code already conforms to the target architecture.
Krzysztof JelskiDownload slides
It's not enough to be great in your favorite web framework or be a local hero of TDD. To have real satisfaction from your work you should get out of your developerish comfort-zone and make a step towards the business. Understand what jobs your customers are performing and how your software helps (or hampers?) that. Be proactive by asking why does business really need all their features. And yes, it's really important that all developers think this way and do not delegate all contact to clients to a business analyst or whoever.
We'll take a look at which approaches, practices and tools help to achieve such an attitude.
Gerrit at Eclipse Foundation have really long history. Initially only EGit and JGit projects could use this tool, but starting from February 2012 Gerrit become fist class citizen in Eclipse ecosystem. Every Eclipse Foundation's project can immediately start using its powerful code review capabilities. Capabilities that together with TDD and CI create safety net against bugs for software development.
For quite long time Gerrit features set was pretty closed and adding new functionality required upstream code base changes. That means either you ended up in port and rebase nightmare or contributed your changes back to community... where they could not have been accepted because they solve your domain's problem not something that is vital for the community edition.
Plugin support in Gerrit was initially introduced in version 2.5. Since then amount of available extension points substantially increased. In this presentation we will understand Gerrit plugins architecture. We will discuss extensions and plugins especially differences between them and which one to choose when. We will see how to combine everything together (including WEB UI) to get your first full blown Gerrit plugin.
Zaawansowane warsztaty Android przedstawiające użycie Location API. Warsztaty przybliżają uczestnikom Location API, Map API v2 oraz osmdroid (opensorsową platformę z mapami). Celem warsztatów jest nauka używania Location API na praktycznych przykładach.
- pobieranie lokalizacji w "stary" sposob i przez google play serwisy
- maps api v2, użycie, poligony, overlaye, jakies ciekawsze usecasey
- alternatywa dla map googlowych - osmdroid
- testowanie apek lokalizacyjnych - pozorowane położenie
- przykłady użycia, problemy, tips&tricks
Software engineers everywhere are looking for faster, easier ways to get their jobs done. They don’t want to worry with infrastructure or installing software—they just want to code!
In this workshop, attendees will learn how they can leverage JazzHub, a Software as a Service (SaaS), and Codename: BlueMix, a Platform as a Service (PaaS), to develop applications in the cloud without having to install any software on their devices.
Bring your laptop, tablet, or smart phone and get ready to code! Attendees will break into small teams and work together to improve an existing application. They will be able to track their work, file defects, update their application’s code, and see their application running live. They will also have the option of setting up automatic deployments, so they can see DevOps in action!
Krzysztof JelskiDownload slides
Agile has mostly solved the problem of delivering working software efficiently. We are quite good at ""creating software right"". Now it's time to improve on the trickier part - how to ""create the right software"". What we want is software that has an impact on our clients' lives or businesses.
Impact Mapping is a great tool to help teams build only what is really needed. It helps by aligning activities of all delivery activities with business goals. It also helps to expose and communicate assumptions. The process itself is visual and collaborative, which works as if you added at least 50 IQ points to each team member.
The session will include a short introduction to Impact Mapping. We'll also see how an Impact Map can help in identifying assumptions and making strategic decisions.
This session works best in a workshop settings, where participants sit in small groups. If room won't allow, participants will do small activities themselves to practice Impact Mapping at least a bit.
Tugdual GrallDownload slides
In this workshop you will learn how to use MongoDB server and develop your first application on a Document Oriented Database. During this session we will see:
- Installation and Configuration
- CRUD Operation
- Java Drivers
- Document Design
- Advanced Topics: Aggregation Framework, Geo Queries, Full Text Search
- Deployment consideration
Startup Company founders love their cause. But in order to succeed quickly they might like to get some help in presenting and articulating their ideas. Both to others, to investors, and to themselves.
The central idea of this course is to teach how to quantify your top few critical objectives, for your startup project, and for your startup product. Most people do not know how to do that. We will show you how.
18 June 2014
Tom Gilb and Kai Gilb have, together with many professional friends and clients, personally developed the Agile methods they teach. The methods have been developed over five decades of practice all over the world in both small companies and projects, as well as in the largest companies and projects.
There are many organisations, and individuals, who use some or all of their methods. IBM and HP were two early corporate-wide adopters (1980, 1988). Recently (2012) over 15,000 engineers at Intel have voluntarily adopted the Planguage requirements specification methods; in addition to practicing to a lesser extent Evo, Spec QC and other Gilb methods. Many other multinationals are in various phases of adopting and practicing the Gilb methods. Many smaller companies also use the methods. They have advised top management at UK Companies on Business Agile in 2013 and earlier.
300 EUR / 1200 PLN
- Cost of one-day training led by two trainers.
- Training materials in electronic format
- Lunch and coffee break.
- Company Goals: the accomplishments that set you apart.
- Stakeholder levels, critical needs.
- Product and Service requirements: making them measurable, and ambitious, and avoiding premature commitment to bad technology.
- How to quantify, and clarify, any quality concept
- A planning language for presenting and discussing your ideas.
1 day (8h)
By attending this course you’ll get a good beginners understanding of how to clarify and quantify all your business and technical objectives competitively, independently of the strategies and technologies necessary to reach them.
This course is intended for startup leaders looking for a way to express critical ideas extremely clearly, but also flexibly share ideas with their team and investors and to make sure they deliver clear value early in practice, build credibility, cash flow and experience.
You and your team might need some help after the course in making initial plans tailored to your startup. Some people, however, can do a great job without such follow-up, just based on the course alone.
A digital library with voluminous papers, course slides, case studies, will be made available during and after the course, in a dropbox. This includes two textbooks by the instructors.
Software is the heart and soul of a vast number of products and business processes; every year the ability to develop robust software systems quickly and reliably becomes more critical to the world economy. Yet all to often companies use software development processes that were born when systems were coded in assembly language and computer hardware was more expensive than programmers' salaries.
Today we have pervasive internet, omnipresent social media, big data, and massively scalable hardware. These advances have flourished largely outside the realm of traditional software development practices, and they call into question the conventional wisdom of what it means to develop, scale, and maintain excellent software-intensive systems.
It's time to re-think our approach to software development processes, our perception of the people who create software, and our governance systems. This two day workshop presents an alternate framework for thinking about developing software-intensive systems - one based on Lean principles and focused on innovation.
- 12-13 June 2014
- Krakow, Poland
Mary Poppendieck has been in the Information Technology industry for over thirty years. She has managed software development, supply chain management, manufacturing operations, and new product development. She spearheaded the implementation of a Just-in-Time system in a 3M video tape manufacturing plant and led new product development teams, commercializing products ranging from digital controllers to 3M Light Fiber™.
Tom Poppendieck has over 25 years of experience in computing including eight years of work with object technology. His modeling and mentoring skills are rooted in his experience as a physics professor. His early work was in IT infrastructure, product development, and manufacturing support, and evolved to consulting project assignments in healthcare, logistics, mortgage banking, and travel services. Tom holds a PhD in Physics and has taught physics for ten years.
Mary and Tom have pioneered the application of Lean Thinking to software development and documented their principles in books: Lean Software Development: An Agile Toolkit, published in 2003, its sequel, Implementing Lean Software Development: From Concept to Cash, published in 2006, Leading Lean Software Development: Results are Not the Point in 2009, and The Lean Mindset: Ask the Right Questions in 2013.
For the last several years they're helping companies around the world implementing Lean principles by providing lectures, training and coaching.
- Early birds: 3000 PLN or 715 EUR net (till April 11, 2014)
- Regular: 3400 PLN or 815 EUR net (till May 21, 2014)
- Late booking: 3800 PLN or 915 EUR net (from May 22, 2014)
- Cost of two-day training led by two trainers
- Training materials in electronic format
- Lunches and coffee breaks
Number of seats limited.
- Build the Right Thing
- Beyond Requirements
- The Roles of Engineering & Design
- Feedback: Lessons from Lean Startup
- Build the Thing Right
- Learn to See Waste
- Mistake-Proof the Process
- Map the Value Stream
- Focus on Flow
- Manage Workflow
- Limit Work-in-Progress
- Increase the Pace of Delivery
- Build the Right Organization
- Leadership Roles
- Multi-Disciplined Teams
- Learn to Improve
- Improvement Kata
- The Coaching Role
- Problem Solving
By attending this course you will learn:
- How to discover what customers really want.
- Who should design/engineer solutions to customer problems.
- How to look at your process from a customer's point of view and identify waste.
- What's wrong with software testing and what you have to do to fix it.
- What organizational structures are most likely to foster innovation.
- Scheduling strategies that permit confident promise-dating and reliable delivery.
- Tools for problem solving that everyone in the organization can use.
- Leadership roles that work - from the perspective of followers.
This course is intended for managers, leaders and all people involved in making decisions about how software-intensive products are developed.
No special knowledge is required, however you will be asked to read short articles and watch videos on each topic prior to the workshop - come prepared for thoughtful discussion!
- 2 days (16h)
Mary and Tom website offers videos, podcasts and essays on Lean Software Development.