A single conversation with a wise man is better than ten years of study.
~ Chinese Proverb ~


"Every Rose Has Its Thorn": Taming automated tests beast.

Wojciech Seliga

Download slides

Automated tests are just great, right? All kinds: unit, UI, functional, integration, acceptance.


They are your responsibility, they have to be maintained, they are your baggage too, they may slow down your project to a halt, they can doom you … unless you are careful and think instead of act blindly.

This session shows various common but costly mistakes and misconceptions around automated tests on various abstraction levels which often lead to serious problems in software projects – especially those long-lived where a lot of automated tests get accumulated over years.

The presentation demonstrates those practices, design decisions and organizational changes which helped us steer our projects through the waves of automated tests hell. A lot of examples and remedies base on my experience with Atlassian JIRA – a Java-based product developed now for about 10 years with many thousands of automated tests on various levels of abstractions and using various technologies.

(map Clojure everyday-tasks) - Clojure for real-world, day-to-day programming

Jacek Laskowski

Download slides

Clojure is often described as a small Java library for some concurrency improvements. It's not easy to write a proper concurrent application on JVM and any help in this area is always warmly welcome. In general, Clojure is a Lisp-like functional programming language that runs on the Java Virtual Machine (JVM). During this presentation I'm going to show the language as a tool to build standalone as well as web applications. Many problems are much easier solved by functional paradigm and not only does it give considerable time savings for its concise, almost free-rule syntax, but also for its take on concurrency. OOP techniques like polymorphism, encapsulation, design patterns and many more are a part of the language, despite it being functional language and seem extendable on an unprecedented scale, e.g. multiple dispatch. I'm going to show it using idiomatic Clojure code to tackle real-world, everyday programming challenges that ultimately turn out not to be so. The presentation is more practical than theoretical one, so be prepared for intense Clojure programming session. You'll be surprised how easy it is to use the small Java library called Clojure and make it your language of choice for the years to come. It's really that easy, and you'll have a chance during the presentation.

8 klasycznych technik programistycznych leżących u podstaw nowoczesnej inżynierii oprogramowania (Polish)

Sławomir Sobótka

Download slides

Zdobycze współczesnej inżynierii oprogramowania są niczym innym jak syntezą sprawdzonych i ugruntowanych technik klasycznych. Przykładowo Domain Driven Design to profilowanie analizy i projektowania Object Oriented stricte na potrzeby systemów biznesowych. Command-query

Responsibility Segregation to naturalny wynik ewolucji klasycznych architektur warstwowych.

Niejednokrotnie bywa tek, że zespoły projektowe nie mogą pozwolić sobie na drastyczną zmianę metodyki tworzenia systemu obarczonego garbem historii.

Podczas prezentacji będę chciał przekonać uczestników, że o ile nagła zmiana metodyki może być kłopotliwa, to bez problemu możemy czerpać z DDD i CqRS poszczególne techniki po to aby metodą małych kroków zmieniać jakość kodu.

Myślą przewodnią prezentacji jest następująca teza: myślenie inżynieryjne (zdefiniujemy czym jest myślenie w stylu inżyniera) jest ważniejsze niż narzędzia i metodyki a brak tego stylu myślenia jest głównym powodem problemów technicznych w naszej branży.

Podczas prezentacji będą przedstawiane kolejne techniki programistyczne w odniesieniu do ich dosłownych odpowiedników ze świata inżynierii lądowej i mechaniki konstrukcyjnej. Innymi słowy będziemy inspirować się dokonaniami branży, które są nieco bardziej dojrzałe aby dostrzec, że pewne klasy problemów posiadają sprawdzone style rozwiązań.

Podczas prezentacji zostaną przedstawione następujące techniki programistyczne:

  • adaptacja nieodpowiednich interfejsów: Value Objects jako adapter typów technicznych do koncepcji biznesowych; wpływa na testability
  • modelowanie ról i dynamicznych odpowiedzialności obiektów; podejście Extension Objects i Role Object
  • wariacja zachowań: Strategy Design Pattern jako odpowiednik funkcji; wpływ na testability
  • coupling - epicentrum wstrząsów w projekcie. Teoria trzech rodzajów couplingu oraz jego hermetyzacja w fabrykach.
  • zdarzenia - nie tylko kliknięcia w buttony. Zdarzenia jako część modelu biznesowego; wykorzystanie w celu uzyskania: skalowania, wydajności, decouplingu kontekstów, składowania modelu behawioralnego, budowy architektury pluginowej
  • maszyna stanów - naturalny model dla wielu problemów biznesowych
  • specyfikacje - jedyny racjonalny sposób na modelowania złożonych, dynamicznych reguł; wpływ na testability
  • wizytator - sposób na instrukcje switch

A Walking Tour of Spring 3.1

Josh Long

Spring 3.1 is here, and it offers a LOT! The question is - what does it offer for you? Josh Long will introduce Spring 3.1 in this fast paced tour of all the new features, including profiles, Hibernate 4 support, XML free web applications, numerous updates to the code-centric component model, the environment abstraction, a caching abstraction, an improved REST API, and much more. Josh introduces numerous new features in terms of an application that he'll introduce along the way.

Acceptance Test Driven Development with Arquillian

Bartosz Majsak

We all know that unit tests are great, but relying only on them is most of the times just an illusion of safety. Eventually we need to verify how our components are interacting or whether running in the target environment does not end up with some unexpected behaviour. Last but not least it all amounts to whether your application is providing the end user what he or she is really expecting. But how can Arquillian help us saving our users from frustration and keep them sane?

Along this journey we will see that the Arquillian ecosystem is way more than just integration testing. We will dive into the concept of ATDD and demonstrate how to build higher-level, end-to-end functional tests using the Arquillian Drone extension together with a WebDriver's concept called Page Objects. This concept makes our tests cleaner by providing reusable web testing components. To make it even better we will sugar coat our tests with a Groovy DSL for Behaviour Driven Development.

If you care about quality of your software you definitely shouldn't miss this talk!

Agile Design

Paweł Lipiński

Software design is a tricky thing. Depending on a team and a project management method it may mean different things. Some teams do detailed design, with lots of UML diagrams and discussions on design patterns. Others say that TDD is enough and the proper design should emerge during the work. During the presentation I will show a blend of these that works for me. I will tell you when do I do up-front design, what kind of patterns do I choose, when do I rely on TDD only, and how I try to mix these approaches to make both my work and the software design agile.

Agile, Lean and Startups practice & principles to create the ultimate value creation machine

Barry O'Reilly

Download slides

Startups. 4 people in a room changing the world. Fluid, optimised, responding dynamically to changes in the product based on detailed customer data to drive value and build their proposition. No bureaucracy, no waste just beauty.

Agile. 10 people in a room fighting an organisation. A system, bloated, ridged and wasteful. Challenging a business to change its perspective on product development and deliver amazing products.

While it sounds like Cinderella and the ugly sister both have lessons to learn from one another. Principles are as important and useful in established companies as they are in the startup world. Lean Startup isn't just about how we can create an amazing product - its about how we can learn from the results of our efforts to improve everything we do. Agile is an iterative, incremental approach to software development. Lean is a customer focus value creation process.

They are all ultimately searching for an answer to the question 'How can we learn more quickly what works, and discard what doesn't?

This presentation reviews all approaches to seek to leverage all disciplines to the achieve the ultimate outcome.

Build Trust in Your Build to Deployment Flow!

Frederic Simon

Download slides

Frequently deploying to production puts bigger pressure than before on DevOps to make sure the good, qualified application is provisioned with no mistakes.

This session will explore some common pitfalls with traditional Continuous-Integration that increase risk, introduce manual input and human error, and generally make DevOps cringe before hitting the “deploy” button.

We will then demonstrate automation techniques that overcome these issues using popular tools, like Maven, Gradle, your CI server, custom scripts and a Binary Repository.

Whether you are building software for the cloud or in-house, this presentation will show you how to have completely automated production builds that release applications which are fully traceable, managed and ready to be provisioned with no fear!

Building hybrid mobile apps for iOS and Android with PhoneGap and JQueryMobile

Martin Burlinski

Java has delivered "write once, run anywhere" to the world of desktop software development. Can the same be done for mobile platform? Join us to we explore how to use PhoneGap and JQueryMobile in an attempt to achieve the same for iOS and Android. During this talk we will build a hybrid application that will run on both platforms and have the non-trivial ability to access device’s native APIs.

Challenges in maintaining a high performance search engine written in Java

Simon Willnauer

Download slides

During the last decade Apache Lucene became the de-facto standard in open source search technology. Thousands of applications from Twitter Scale Webservices to Computers playing Jeopardy rely on Lucene, a rock-solid, scaleable and fast information-retrieval library entirely written in Java.

Maintaining and improving such a popular software library reveals tough challenges in testing, API design, data-structures, concurrency and optimizations. This talk presents the most demanding technical challenges the Lucene Development Team has solved in the past.

It covers a number of areas of software development including concurrency & parallelism, testing infrastructure, data-structures & algorithms, API designs with respect to Garbage Collection and Memory efficiency and efficient resource utilization.

This talk doesn’t require any Apache Lucene or information-retrieval background in general. Knowledge about the Java programming language will certainly be helpful while the problems and techniques presented in this talk aren’t Java specific.

Cloud Foundry and Spring, a marriage made in heaven

Josh Long

This talk will describe the Cloud Foundry Open PaaS (Platform as a Service), with its open source, multi-framework, multi-service, multi-cloud model, and will explain in depth how to use Cloud Foundry services effectively from Java/Spring applications. Cloud Foundry allows developers to provision apps in Java/Spring, Ruby/Rails, Ruby/Sinatra, Javascript/Node, and leverage services like MySQL, MongoDB, Reddis, Postgres and RabbitMQ. It can be used as a public PaaS on CloudFoundry.com and other service providers (ActiveState, AppFog), to create your own private cloud, or on your laptop using the Micro Cloud Foundry VM. In this talk, Josh will describe the tools available for Spring application developers using Cloud Foundry: STS (Spring Tool Suite) Cloud Foundry Plugin, the Cloud Foundry Maven plugin or the vmc command line. Josh will also describe how Cloud Foundry exposes service information to applications, and the various options Spring app developers have to leverage these services:

  • using the auto-reconfiguration mechanism that allows using services without any modifications to the app
  • using the “cloud” namespace to have an explicit control over consuming services
  • combining the profile support in Spring 3.1 with the “cloud” namespace to create applications that allow explicit control over services, while allowing applications to run locally or in Cloud Foundry without any change.

The talk will include demos of the Spring app development lifecycle with Cloud Foundry: local development with STS, local deployment to Micro Cloud Foundry for testing, deployment to CloudFoundry.com.

Code Craft

Nathaniel Schutta

Despite what some developers think, we spend a lot more of our time reading code, code that was often written by someone that isn't around anymore. How do we deal with this common scenario without resorting to burning our predecessor in effigy? Better, how can we write code in such a way that our successors will heap effusive praise upon us at the mere mention of our name? During this talk, we'll read actual code discussing ways it could be improved. As we work through real examples, we'll explore the importance of patterns, principles like SOLID and SLAP and essential practices like unit testing and continuous integration.

Complexity of Complexity

Ken Sipe

Of all the non-functional requirements of software development, complexity receives the least attention and seems to be the most important from a long term standard point. This talk will look at some of forces that drive complexity at the code level and at a system level and their impact. We will discuss what causes us to over look complexity, how our perception of it changes over time and what we can do about it?

In this session we will break down the meaning of complexity and simplicity and measure the application of those means against the common software development dogma. Looking at common development trends and pressures, we'll discuss where simplify does and doesn't help. We will examine areas of development which at first glance seem to be simple (such as the creation of an equals method in Java), that end up being difficult or impossible based on normal constraints. We will example the drivers of complexity with some discussion on what you can do about it. This session will finish with a discussion around several challenges to high scale software architectures and how to keep it simple.

Concurrency without Pain in Pure Java

Venkat Subramaniam

Programming concurrency has turned into a herculean task. I call the traditional approach as the synchronized and suffer model. Fortunately, there are other approaches to concurrency and you can reach out to those directly from your Java code. In this presentation we will discuss the actor based concurrency and also the software transaction memory. We will then develop examples using AKKA and compare the power of these approaches in contrast to the traditional approach.

Continuous Delivery Best Practices

Ken Sipe

There is a new “movement” in software development circles called DevOps. It is about the automation of development best practices as well as the automation of the deployment pipeline. Answer this question, “How long does it take your organization or team to push 1 line code of change into production?” That’s what this session is all about.

See what LinkedIn is doing… a company who is pushing production releases multiple times a day. Their approach may not be best for you, but we can learn from it. This session will look at all aspects of automating the delivery pipeline with a focus on “Continuous Delivery”, a term coined in the Agile Manifesto.


Mike West

Download slides

Dart is a new programming language for structured web programming. The Dart project includes a language, libraries, a virtual machine, and even an IDE. It also takes a fresh look at DOM and HTML interfaces. Join Mike West, a Developer Advocate with the Chrome team, as he gives a tour of Dart and its motivations.

Demanding Professionalism

Robert C. Martin

The vast majority of software developers have yet to learn the practices and disciplines that constitute professional behavior. That's because those practices have only just recently been defined. The software industry is barely fifty years old. It has taken nearly that long to figure out what software professionalism is. It is only in the last few years that a set of generally accepted software practices have been defined. But now they are here, and it's time for management to demand that professional behavior. In this talk, Robert C. Martin will describe these disciplines, and practices, and will discuss how to raise the professionalism bar in your projects and teams.

Designing for Mobile

Nathaniel Schutta

The word just came down from the VP - you need a mobile app and you need it yesterday. Wait, you've never built a mobile app...it's pretty much the same thing as you've built before just smaller right? Wrong. The mobile experience is different and far less forgiving. How do you design an application for touch? How does that differ from a mouse? Should you build a mobile app or a mobile web site? This talk will get you started on designing for a new, and exciting, platform. Whether that means iPhone, Android, Windows Phone or something else, you need a plan, this talk will help.

Developing for Web, In Web - Eclipse Orion

Szymon Brandys

Download slides

Orion is an open tool integration platform entirely focused on developing for the web, in the web. It is one of the rookie projects of the year according to Black Duck Software and a nominee for Most Innovative Project by Eclipse Foundation.

If you want to start developing in Web without installing any tools on your laptop or mobile device, Orion is for you. Hear about its current state, the design and plans for this year. See how you can extend it with additional capabilities including support for new languages or integrate it with other well-known services.

See wiki.eclipse.org/Orion for more information about Orion.

Economic Games in Software Projects

Matthew McCullough

The full title of this talk reveals its grand aims: Game Theory and Software Development: Explaining Brinksmanship, Irrationality, and Other Selfish Sins

Once in a while, a topic, seemingly orthogonal to software development, presents a great opportunity to showcase how engineering can benefit from knowledge of seemingly more social disciplines. In this talk, the fundamental principles of economics' Game Theory are compared to often inexplicable behaviors and decisions we frequently observe in programming projects.

Then, with a good Game Theory vocabulary under your belt, several standard games are studied in a manner that will allow you to better manipulate the inputs. These games are present in web framework choices, project planning and estimation, and even team decisions on which bug to solve first. With a good understanding of Game Theory, you'll be able to understand and influence what you previously labeled 'irrational behavior.' It turns out to be far from irrational when examined in the context of self-preservation. Once these behaviors are understood, you will be able to ethically influence the outcomes to your personal and corporate advantage.

Ewolucyjna architektura (Polish)

Mariusz Sieraczkiewicz

Na co dzień najbardziej skupiamy się na dostarczaniu klientom wartości biznesowej. Wdrożenie za wdrożeniem, robimy co możemy, ale praca użytkowników była łatwiejsza. Jako jeden z minusów tej projektowej gonitwy pojawia się dość często kłopot z architekturą systemu.

W trakcie prezentacji zajmiemy się sposobami na to, aby architektura systemu dojrzewała razem z wymaganiami. Będą interesować następujące pytania:

  • Jak zdefiniować proces ewolucji architektury?
  • Jak wdrożyć ten proces?
  • Jak określić zakres odpowiedzialności architekta?
  • Jak powiązać proces ewolucji architektury z cyklem produkcyjnym w organizacji?
  • Jak zarządzać wiedzą o architekturze i projektowaniu w zespole?

GEB - Very Groovy browser automation

Luke Daley

Download slides

Geb is a browser automation solution for Groovy. It brings together the power of WebDriver, the elegance of jQuery content selection, the robustness of Page Object modelling and the expressiveness of the Groovy language. Geb enables more expressive, more concise, and (very importantly) more maintainable web tests.

In this session we'll explore the foundations of Geb and illustrate how it uses the language features of Groovy to make web automation and testing productive and effective. After exploring the basics we'll explore Geb's rich Content DSL and discuss patterns for achieving maintainable tests. We'll also look at how it combines with Spock, the Enterprise ready testing framework, to enable low cost executable specifications that describe user behaviour, not browser details.


Luca Milanesio

Download slides

Gerrit is the Git repository and code-review engine behind the Google Android Development process, used by over hundreds of thousands of developers so far worldwide. Gerrit started as a simple code-review system used internally in Google, built from the experience of Google Mondrian (made by Guido van Rossum) and applied to Git SCM.

Gerrit revolutionise the way you organise your Git development by providing a natural and effective way to integrate patches, socialise with your team changes and define a workflow to promote code from prototype stage to production release.

Gerrit has a large ecosystem of integrations, starting from Jenkins build triggers to code-changes association with Jira artifacts.

See it in action and learn from Luca how to get started with Gerrit. You can make your development lifecycle better from now!

Gradle plugins - build automation evolved

Szczepan Faber

We'll kick off with a quickie intro to Gradle, powerful yet flexible build system for the jvm platform. Then we'll take a deeper dive into the Gradle plugins API. You'll learn how to develop plugins, the different ways to organize and distribute plugins, and the way you should use plugins as means of extending the Gradle DSL to describe your build domain in a concise and idiomatic way. Expect lots of interactive coding and little slides.

HTML5 For Developers

Nathaniel Schutta

Wonder what all the fuss is about HTML5? This session will show you how to leverage HTML5 in the applications you are building today. We'll start with a gentle overview describing just what HTML5 is all about and then we'll delve into the details. We'll look at the new elements HTML5 brings to the table, why canvas isn't just something you find in the art department, how geolocation can find Waldo and much much more.

After a brief overview, we'll talk all about feature detection then jump into web forms. We'll discuss the new elements that HTML5 brings to our toolbox. After a spin around the canvas API, we'll touch on geolocation, local storage/offline and finish up web sockets.

Hibernate puzzlers

Patrycja Węgrzynowicz

Hibernate is an elegant, straightforward, and easy to use library. This is undeniably true for simple domain models. What about more complex ones? It turns out that in case of complex domain models we usually run into interesting hibernate issues relating to performance or correctness.

Here, we will present several puzzles from hibernate and JPA to illustrate tricky use cases that have interesting side-effects, lead to incorrect behavior, or impose significant performance overhead. Come and see if you can solve them.

How to Change the World

Jurgen Appelo

“How do I make my managers more Agile?”

“How can I convince developers to educate themselves?”

“How can I make customers more cooperative?”

“How do I start a European network of Agile and Lean practitioners?”

When transforming organizations and other social systems people usually encounter obstacles. And these obstacles very often involve changing other people’s behaviors. Of course, we cannot really _make_ people behave in a different way. We also cannot really make people laugh, and we cannot really make people happy. But… we can certainly try!

This session is about Change Management 3.0. It is a new change management “super model” which views organizations as complex adaptive systems and social networks. The Change Management 3.0 supermodel wraps various existing models (PDCA, ADKAR, Adoption Curve and The 5 I's). It lists a few dozen hard questions that can help people in their attempts to change the behaviors of other people in an organization and beyond. No matter whether you are a manager, Scrum Master, Product Owner, software developer or writer, anyone will find it useful to know how to change the world around them.

Infinispan in 60 minutes

Manik Surtani

So you've heard about this cool Infinispan project and want to know what it is all about? Then this is definetly for you! Manik Surtani will give you an overview of the Infinispan ecosystem from which you'll take home:

  • what is Infinispan
  • the main use cases and how you can benefit from it
  • adding scalability and performance to data-centric applications using a distributed in-memory grid
  • its key features and differentiators in the data grid world

Integrating JVM Languages

Venkat Subramaniam

Quite a few languages have raised to prominence on the JVM. A frequently asked question is about integrating Java code with these. This session answers that very specific question. Learn how to integrate code written in Java, Clojure, Scsla, and Groovy. We will discuss both language level integration and architectural boundaries.

Java, Kinect and Gestural Interfaces

Simon Ritter

Download slides

The Kinect has delivered a low cost sensor aimed at games playing without a physical controller. From the beginning people have been hacking the Kinect and using it for all sorts of weird and wonderful applications. This session will look at how the Kinect sensor can be used from Java applications using an open source API. We’ll also look at how the Kinect can be combined with other sensors like accelerometers, bend sensors and a compass to create a truly immersive application. The session will include plenty of exciting demos using JavaFX and JMonkeyEngine to drive the user interface.

JavaFX 2.0 and Scala, Like Milk and Cookies

Stephen Chin

JavaFX 2.0 is the next version of a revolutionary rich client platform for developing immersive desktop applications. One of the new features in JavaFX 2.0 is a set of pure Java APIs that can be used from any JVM language, opening up tremendous possibilities. This presentation demonstrates the benefits of using JavaFX 2.0 together with the Scala programming language to provide a type-safe declarative syntax with support for lazy bindings and collections. Advanced language features, such as DelayedInit and @specialized will be discussed, as will ways of forcing prioritization of implicit conversions for n-level cases. Those who survive the pure technical geekiness of this talk will be rewarded with plenty of JavaFX UI eye candy.

JavaFX for Business Application Developers

Michael Heinrichs

JavaFX is an environment for building rich client applications. Using a scenegraph at its core and providing many advanced features, e.g. effects, animations, media-support, it greatly simplifies the task of implementing expressive user interfaces with engaging user experience. The API is entirely provided as a Java API making it also available for other programming languages that run on top of the JVM.

This talk focuses on functionality in JavaFX, that is usually most interesting for business application developers, e.g. working with the SceneBuilder for rapid UI development, using layouts, UI controls with data-binding, CSS styling, and FXML. All concepts will be explained and demoed using a JavaFX client for a JavaEE 6 application.

After this talk you will have a good idea of how JavaFX can help you write more compelling user interfaces for your business applications efficiently.

Kotlin: A cool way to program for JVM

Andrey Breslav

Download slides

Kotlin is a statically typed JVM-targeted OO-programming language, recently introduced by JetBrains. The language is under development, but we can already demo quite a few cool things you can do with it, such as:

  • Safer programs with static null checks;
  • Concise code with type inference and first-class functions (closures);
  • Convenient internal DSLs and fluent interfaces;
  • Strong and flexible typing with reified, variant generics;
  • and much more!

Leading Individuals

Tomasz de Jastrzebiec Wykowski

Download slides

Why people behave and react so differently? Why it’s so hard for them to do what they’re told to? Why it’s so difficult to manage, motivate and change them? Why they just cannot learn the “people skills”? And finally, what statistical variation has to do with people’s achievements and why you should abandon performance appraisal? If you’d like to hear answer to any of those questions join Tomasz in his walk through different science disciplines from statistical process control through psychology to cognitive science. This talk, based on researches, experiments, theories and experiences, explains some of the reasons behind people’s behaviors, what drives them, what factors are impacting their effectiveness at work and why some of traditional methods does not work. Finally, you’ll leave the session knowing how to make working and living together with others little easier.

Lift from a JEE perspective

Andreas Krogh

Download slides

How does Lift play with the JEE-stack? How to leverage value of existing frameworks in the JEE stack using Lift. How does Lift play together with common frameworks like JSF, Struts2, Spring and JPA? How to implement DomainDrivenDesign usgin JPA and JSR-303 validation using the Lift/Scala combination. In this presentation, Andreas Krogh tries to answer these questions with an example application and shows how Lift can co-exist with other frameworks and make the migration-path easier for anyone considering switching an existing JEE application to Lift.

Mastering Java bytecode with ASM

Anton Arhipov

At first sight Java bytecode can seem an obscure piece of low-level magic. But there are tons of open-source Java frameworks in the wild that do bytecode instrumentation and all kind of magic. What if you’d like to contribute or fix a bug? Understanding Java bytecode may appear quite helpful once you have to solve problems that are related to binary weaving of Java classes, and some things you can do are just plain freakin' cool. This talk will introduce you the JVM and bytecode basics using live coding demo with ASM (http://asm.ow2.org/) and creating a cool application live.

Micro services - Java, the Unix Way

James Lewis

Download slides

"Write programs that do one thing and do it well. Write programs to work together" was accepted 40 years ago yet we have spent the last decade building monolithic applications, communicating via bloated middleware and with our fingers crossed that Moore's Law keeps helping us out. There is a better way.

Micro services. In this talk we will discover a consistent and reinforcing set of tools and practices rooted in the the Unix Philosophy of small and simple. Tiny applications, communicating via the web's uniform interface with single responsibilities and installed as well behaved operating system services. So, are you sick of wading through tens of thousands of lines of code to make a simple one line change? Of all that XML? Come along and check out what the cools kids are up to (and the cooler grey beards).

This is a talk about building micro-services using simple java tools <warning: contains some Architecture>

MongoDB: Scaling Web Application

Ken Sipe

Google “MongoDB is Web Scale” and prepare to laugh your tail off. With such satire, it easy to pass off MongoDB as a passing joke… but that would be a mistake. The humor is in the fact there seems to be no end to those who parrot the MongoDB benefits without a clue. This session is about getting a clue.

Get past the hype and hyperbole associated with NoSQL. This session will introduce MongoDB through live working sessions demonstrating the pros and cons of MongoDB development. The session will then focus on a recent short project focused on large scale. We’ll discuss database design to support high scale read access. Throughout this case study we will discuss the consequences of the MongoDB choice. The session will finish with a review of the production topology to support growth in scale.

Node.js: The Good, The Bad and The Ugly

Tomasz Cejner

Over past few years, JavaScript paved the way from browser scripting language to world of server side. There have been some attempts in the past, but most recent one captured big attention and excitement.

Node.js is scalable, event-driven environment for building network programs using JavaScript. It is built on top of V8 engine that compiles JavaScript into machine’s native code and asynchronous I/O toolkits for each supported platform.

Node concurrency model is based on asynchronous event processing instead of creating threads for every connection, which may show much better memory efficiency. Let’s see if Node is a silver bullet, a new killer application stack that will rule the backend world.

Non blocking, composable reactive web programming with Iteratees

Sadek Drobi

Download slides

Being a part of the wild wild web, your application is encompassed by a lot of streams of live business, social events and messages. It is becoming hard for any modern application to resist integrating into these flows of data. To do so, however, you need the appropriate paradigm with a composable model to consume, combine, forward and publish these live streams with minimal and predictable consumption of resources (CPU, memory, ...). Play2, a web framework targeting Java and Scala, uses functional programming and a model called Iteratee to respond to these needs.

Play 2.0, a Web framework for a new era

Sadek Drobi

The Play framework revolutionized the Java Web application development, by bringing back simplicity and agility contrasting the so-called standard way of writing enterprise applications. Moving forward, technology and the Web have evolved. The Web has become the central point of all applications. The whole Web architecture is fast moving towards real-time, and the emerging requirements of project profiles have put into question the classic assumptions, like SQL as the exclusive datastore technology. At the programming language level we've witnessed some monumental changes with several JVM languages, including Scala, gaining popularity. In this talk I will introduce Play 2.0 a Java and Scala Web application framework, its asynchronous model, its extensibility, its scalable architecture and how does it address tomorrow challenges.

Pointy haired bosses and pragmatic programmers: Facts and Fallacies of Software Development

Venkat Subramaniam

Creating a successful, quality, maintainable product take a lot more than coding-it takes innovation and a good dose of discipline. It takes smart people who question the status-quo, figure our ways to make themselves and their teams productive, and maintain agility without compromising quality and sustainability. In this presentation, award winning author, programmer, and mentor Dr. Venkat Subramaniam will discuss some of the facts and fallacies that affect our ability to succeed in this exciting field. He will remind us about the key ingredients of success and will discuss ways to remove the impediments to clear the way to realize our full potential, as individuals and as an organization.

Scala for the Intrigued

Venkat Subramaniam

Scala is a statically typed, fully OO, hybrid functional language that provides highly expressive syntax on the JVM. It is great for pattern matching, concurrency, and simply writing concise code for everyday tasks. If you are a Java programmer intrigued by this language and are interested in exploring further, this section is for you. We will go through a rapid overview of the language, look at its key strengths and capabilities, and see how you can use this language for your day-to-day programming. This session will be coding intensive, so be ready for some serious Scala syntax and idioms.

Smarter Testing with Spock

Luke Daley

Download slides

Spock is a developer testing framework for Java and Groovy applications. Even though it is fully JUnit-compatible on the outside, Spock isn't just another JUnit clone - its goal is to take developer testing to the next level! With its Groovy-powered and highly expressive testing language, Spock boosts productivity and brings back the fun to testing.

In the first part of this session, Spock's approach to state-based, data-driven, and behavior-based testing will be demonstrated. Next, we will explore some of Spock's extensions, in particular the Grails plugin and the Spring TestContext Framework integration. Finally, we will look under the covers of Spock and write our own extension. Along the way, expect to see lots of code and live demos.

Static Code Analysis and AST Transformations

Hamlet D'Arcy

Download slides

The goal of static analysis is to let your computer find the bugs and problems in your code before your customers do.

This session covers several popular and open-source static analysis tools available in the Java ecosystem today, and shows how we can use them to improve the quality of our software projects. We'll take a look at IntelliJ IDEA's static analysis capabilities as well as other projects like CodeNarc, PMD, AndroidLint, and Groovy 2.0. We'll also take a deep dive into how these tools are built, and how they use a compiler's Abstract Syntax Tree to work their magic.

The Apache Cassandra storage engine

Sylvain Lebresne

Download slides

Apache Cassandra is a distributed database built to handle massive amounts of data on large clusters of community servers. This talk will present the storage engine at the core of Cassandra, motivating the use of a structure akin to a Log-Structured Merge Tree rather than of a usual B-Tree and it's implications for the data model. We will also introduce most of the current features of that engine (secondary indexes, integrated caching, TTL...) including recent developments introduced in Cassandra 1.0 like compression/checksumming and the new leveled compaction.

The Future of the Java Platform: Java SE 8 & Beyond

Simon Ritter

Download slides

With the recent release of Java SE 7 the Java platform is back on the move, addressing the needs of developers as platforms and applications change. This session will briefly recap recent developments in Java SE 7 and the Java Community Process before moving onto the current ideas for features in Java SE 8. Discussions are underway within Oracle about the main themes for Java SE 9 and beyond. We'll conclude with a look at some of the features that are being considered for inclusion in versions of Java as far forward as Java SE 12.

The Java EE 7 Platform: Developing for the Cloud

Arun Gupta

This talk introduces the Java EE 7 platform, the latest revision of the Java platform for the enterprise. The focus of Java EE 7 is on the cloud, and specifically it aims to bring Platform-as-a-Service providers and application developers together so that portable applications can be deployed on any cloud infrastructure and reap all its benefits in terms of scalability, elasticity, multitenancy, etc. The existing specifications in the platform such as JPA, Servlets, EJB, and others will be updated to meet these requirements.

Furthermore, Java EE 7 continues the ease of development push that characterized prior releases by bringing further simplification to enterprise development. It also adds new, important APIs such as the REST client API in JAX-RS 2.0 and the long awaited Concurrency Utilities for Java EE API. Expression Language 3.0 and Java Message Service 2.0 will under go extreme makeover to align with the improvements in the Java language. There are plenty of improvements to several other components. Newer web standards like HTML 5 and Web Sockets will be embraced to build modern web applications.

This talk will provide a complete introduction to the Java EE 7 platform, including different components, and provide a roadmap.

The Mobile App Smackdown: Native Apps vs. The Mobile Web

Nathaniel Schutta

Mobile is the next big thing and your company needs to there. But what does there actually entail? Should you build a native app? On which platforms? Do you have the skills for that? What about the web? Can you deliver an awesome experience using nothing but a mobile web browser? This talk will help you navigate these treacherous waters. We'll discuss the pros and cons of the various approaches and give you a framework for choosing.

Mobile is the next big thing and your company needs to there. But what does there actually entail? Should you build a native app? On which platforms? Do you have the skills for that? What about the web? Can you deliver an awesome experience using nothing but a mobile web browser? This talk will help you navigate these treacherous waters. We'll discuss the pros and cons of the various approaches and give you a framework for choosing.

The Three Laws of Test Driven Development

Robert C. Martin

The jury is in, the case is closed. TDD works, and works well. In this talk Uncle Bob makes the point that TDD is not a testing technique at all. Rather, TDD is a way to ensure good architecture, good design, good documentation, and that the software works as the programmer intended. TDD is a necessary discipline for those developers seeking to become professionals. This talk is half lecture and half demonstration. Examples are in Java and Junit.

Twitter: From Ruby on Rails to the JVM

Raffi Krikorian

Download slides

Twitter, historically, has been one of the Internet's largest Ruby on Rails website. To support the volume of traffic that comes along with that, Twitter has jumped through many hoops: from re-architecting the way it uses Rails to building and running its own custom Ruby interpreter. To help us focus on our core mission of "real-time" we've undergone a transition and are currently running portions of our core logic in the JVM. This has had a side effect of not just improving our efficiency, scalability, and reliability, but it has also given us an opportunity to gain much more flexibility in terms of language and overall architecture.

Vaadin, Rich Web Apps in Server-Side Java without Plug-ins or JavaScript

Joonas Lehtinen

Get introduced to Vaadin open source web framework by its founder. The framework provides a desktop-like user experience on the web without writing any HTML, XML or JavaScript. The user interface is written completely in Java and run at the server-side. Applications are deployed as Servlets, Portlets or to Google App Engine and run in any modern web browser without plug-ins or applets.

Java-developers interested in writing rich desktop-like user interfaces for web should attend

  • no experience of web technologies is needed.
  • Get introduced to server-side RIA frameworks
  • Learn pros and cons compared to client-side RIA and Google Web Toolkit
  • Start writing beautiful web applications with Vaadin

Web Security

Ken Sipe

As a web application developer, most of the focus is on the user stories and producing business value for your company or clients. Increasingly however the world wide web is more like the wild wild web which is an increasingly hostile environment for web applications. It is absolutely necessary for web application teams to have security knowledge, a security model and to leverage proper security tools.

This 1/2 day training workshop on security will provide an overview of the security landscape starting with the OWASP top ten security concerns with current real world examples of each of these attack vectors. The first session will consist of a demonstration and labs using hacker tools to get an understanding of how a hacker thinks. It will include a walk through of the ESAPI toolkit as an example of how to solve a number of these security concerns including hands-on labs using the OWASP example swingset.

The workshop will include several hands on labs from the webgoat project in order to better understand the threats that are ever so common today.

Attendees will come away with the following skills / capabilities: - threat modeling - security audit plan - introduction to Pen testing - key / certificate management - fixing web application security issues

Don't be the weakest link on the web!

Web frameworks shootout

Multiple Speakers

Have you ever wondered what web framework use in your new project? Come to see most compelling web frameworks and make your own opinion.

Vaadin - Joonas Lehtinen

more to come...

What is so cool about Android. 4.x

Lars Vogel

Download slides

Android 4.0 finally merges the source tree for Handsets and Tablets. In this session we will look at the ActionBar, Fragment Support and Drag and Drop and look why these concepts are useful for Android developers.

If time permits we also have a look a the new APIs as for example Calendar and the social API and ViewPager.

What's new in Groovy 2.0?

Guillaume Laforge

Download slides

After a quick look at the key features of Groovy 1.8, including more readable Domain-Specific Languages, concurrency capabilities with the GPars library, and built-in JSON support, we'll dive right into the most important features of Groovy 2.0!

A lot of the Groovy users are using the language as a Java scripting language, or sometimes as a better Java. First of all, not all of them need the dynamic capabilities, nor do they need all the library improvements provided by Groovy. For the latter, Groovy becomes more modular with smaller core modules that you can compose. For the former, in addition to its usual dynamic features, Groovy 2.0 adds static type checking, allowing you to ensure the correctness of your code before it ships and quickly spot early errors at compile time.

Also, not everybody needs dynamic features at all times, and the natural extension to static type checking is static compilation. With static compilation, Groovy 2.0 generates fast and performant bytecode like Java, and shields key parts of your code base from possible interferences of dynamic features, making critical paths both faster and immune to monkey patching. But when you need fast and performant dynamic logic, Groovy 2.0 also features the integration of the "invoke dynamic" support coming up with JDK 7 and beyond.

import continuous.delivery.*;

Toomas Römer

Download slides

When you send a package through FedEx it goes through a tracked, automated process that makes sure that the package arrives promptly at the destination. The same should apply to every commit that you check into the trunk. Continuous delivery describes how this process can be made fully automated and transparent and we will show you how your commits can be "fedexed" to production with the help from Jenkins and LiveRebel.

The main idea of continuous delivery is the deployment pipeline. Every commit that enters the pipeline should go through automated integration and testing and, if successful, produce a release candidate. We will show how Jenkins can be used to orchestrate the process all the way to the staging environment.

Once we're there, the most complicated phase begins. The release candidate needs to be deployed to production, without disrupting the users or introducing risks. LiveRebel makes production updates quick, automated, non-disruptive and immediately reversible. It finishes the job and delivers the updated version right into the users hands.

In this talk we will build a full clustered environment and a deployment pipeline so that commits into the trunk would update a live chat server while you keep on chatting.

Ścisły przewodnik po aspektach miękkich dla ekspertów IT (Polish)

Sławomir Sobótka

Download slides

Tak zwane "miękkie" kompetencje nie są silną stroną nas - "informatyków" (dla niektórych z nas to słowo jest tak samo obraźliwe jak określenie znachor dla lekarza:).

Podczas prezentacji będę chciał przekonać Was, że materię miękką daje się w pewnym zakresie zanalizować, zamodelować, skatalogować i sparametryzować - czyli w pewnym stopniu okiełznać i wykorzystać do własnych celów.

Wszyscy dążymy do miana eksperta w swoim fachu, dlatego na wstępie przyjrzymy się jednemu z modeli rozwoju kompetencji, prowadzącemu do poziomu eksperta aby stworzyć model postaw i strategii jakimi posługuje się ekspert. Następnie zajrzymy w głąb umysłu eksperta aby zrozumieć zachodzące w nim procesy. Przyjrzymy się umysłowi zarówno na poziomie "sprzętowym" jak i funkcjonalnym.

Na poziomie sprzętowym poznamy mechanizm tykania wewnętrznego zegara czasu oraz wpływ hormonów stresu na działanie tegoż mechanizmu (poczucie upływu czasu, ale również wpływ na motywację wewnętrzną). Przyjrzymy się kilku modelom architektonicznym mózgu, w tym modelowi 2 procesorów wykonujące odmienne (komplementarne) wraz z technikami aktywacji procesora Rich, który jest zdecydowanie zbyt wycofany w naszej branży.

Na poziomie funkcjonalnym przyjrzymy się strategiom uczenia się, których zrozumienie pozwala zoptymalizować wydatek energii poświęcany na własny rozwój. Przedstawię również kilka typowych dla naszej branży strategii podejścia do modelowania problemów i typowych błędów kognitywnych.

W drugiej części prezentacji przełączymy perspektywę zmieniając optykę z jednostki na grupę (zespół). Przedstawię kilka popularnych typologii osobowości z uwzględnieniem ich wpływu na rolę w zespole, optymalne zadania, komunikację i motywację - wszystko dostosowane do naszego profilu osobowości.

BOF: Beautiful failures

Jakub Nabrdalik

Download slides

“There is nothing either good or bad but thinking makes it so.” William Shakespeare's Hamlet

We often come back from conferences like this full of good ideas, great examples and high hopes. Then we try to implement those freshly learned, fabulous concepts in our everyday work. Sometimes they work just like advertised. And sometimes they're like Dr Jekyll turning into Mr Hyde.

We’d like to talk about our failures with well recognized, highly recommended stuff. We would like to talk about why it happened, and what have we learned from that. There is nothing good or bad without a context, and we would like to share the circumstances under which things don’t work.

Things like:

  • shared responsibility
  • self organized teams
  • gamification
  • open source
  • standards
  • metaprogramming
  • ‘enterprise’ technologies

We would like you to hear your stories. Let’s learn from each other’s mistakes.

Disclaimer: all projects we'll be talking about eventually ended up successfully ;)

BOF: Cleaner APIs, Cleaner UIs with Visage

Stephen Chin

Visage is a JVM language designed specifically for UI development, with special syntax for hierarchically describing UIs, binding data and behavior, and representing UI specific concepts such as animation, layout, and styles. It also is a full-featured language with a full compiler tool-chain, static compilation to JVM bytecodes, and IDE plug-ins. This talk will demonstrate how to use the Visage language to build UIs for JavaFX 2.0, Apache Pivot, Vaadin, and other Java-based UI platforms. Find out how you can take control of your UI development by writing cleaner, more maintainable UI code using the Visage language in your existing Java projects.

BOF: Game Development with JavaFX

Michael Heinrichs

JavaFX is an environment for building rich client applications. Using a scenegraph at its core and providing many advanced features, e.g. effects, animations, media-support, it greatly simplifies the task of implementing expressive user interfaces with engaging user experience. The API is entirely provided as a Java API making it also available for other programming languages that run on top of the JVM.

During this BOF, a game will be developed that uses the new JavaFX 2.0 library. Starting with an empty project, step by step all parts are coded live while the underlying concepts are explained. At the end of the talk, we will have covered all fundamental components of the JavaFX library (e.g. scenegraph, animation, events, bindings) including example code that uses these components.

After this talk you will have a good impression of what developing with JavaFX 2.0 feels like.

BOF: Groovy and Grails Meetup

Multiple Speakers

Meet and chat with Groovy and Grails gurus.

Groovy/Grails - Guillaume Laforge

Geb - Luke Daley

Gradle - Szczepan Faber

Spock - Peter Niederwieser

BOF: NoSQL and Data Grid

Manik Surtani

The purpose of this BoF is to discuss both NoSQL storage engines as well as in-memory data grids, discuss common overlaps and points of convergence, and discuss standardisation across APIs, wire protocols, and storage formats, to aid greater acceptance in the software development community.

BOF: O kliencie, który wie, czego chce – czyli codzienne sprawy między biznesem a IT (Polish)

Michał Bartyzel

W niezliczonych ilościach departamentów i działów, analitycy, programiści, marketingowcy i sprzedawcy wciąż zadają sobie te same pytania: O czym on/ona mówi? Dlaczego mnie nie rozumie?

W trakcie sesji zastanowimy się nad tym, jak lepiej dogadywać się z tak zwanym Biznesem, a pierwszym krokiem będzie przyjrzenie się przekonaniom, o których prawdziwości jesteśmy absolutnie przekonani. Zapraszam!

BOF: RFID systems security. A contactless use case.

Multiple Speakers

Radio-frequency identification (RFID) is the use of a wireless contactactless systems that use radio-frequency to transfer information.

Those systems are becoming more and more popular. They are used in payment systems, building access and benefits systems.

This new technology opens gates for innovating products but we can not forget about security.

The presentation shows the current applications of RFID systems, it's usage and complexity.

It also shows the security problems around RFID systems and demonstrates new methods for securing such systems.

Presentation also focuses on usage Java for accessing RFID based systems using ISO/IEC 14443 protocols.

BOF: Spring and CloudFoundry

Josh Long

Meet Spring and CloudFoundry expert and ask any question you have around Spring or CloudFoundry.

BOF: TypeSafe stack 2.0 and Scala Community Talk

Rafał Wasielewski

As new JVM-based languages like Xtend are continually being introduced, how will these impact the success of Scala over time?

As Java itself introduces features like modules and lambdas, will Java programmers wishing to add the functional paradigm simply stick with Java?

There has been some debate in the Scala community about the need to add features versus keeping it lean. Can you give us a sense of where Scala is headed? Does Scala need to become a bloated multiparadigm and multipurpose language to be considered mainstream?

Typesafe was founded to provide a set of open source technologies called the Typesafe Stack.

Complementing the stack, we offer a Typesafe Subscription that adds certified builds, professional maintenance, support, and operations tools.

Stack 2.0: Akka, Play, and Scala

Typesafe Stack Version 2.0 contains three distinct technologies that work great together or separately:

Akka (an event-driven middleware), Play (a web framework), and Scala (a programming language). A common thread is our mission to modernize software development on the Java Virtual Machine.

Some of what you'll find in Typesafe Stack 2.0:

Strategies for working in a world of horizontal scale . Modern software plans for more cores and more machines, rather than faster single cores.

• An emphasis on developer agility, productivity, and enthusiasm . Developers want to work quickly and focus on business logic rather than boilerplate.

• Fewer bugs. The Typesafe Stack has tools to avoid bugs up front . For example, Akka helps you avoid tricky thread synchronization issues, and Scala helps you write side-effect-free, typesafe code with fewer opportunities for error.

• An emphasis on pragmatic interoperability . The Typesafe Stack APIs can be used from Java or Scala or both; and they can be adopted incrementally. It's as simple as adding some jars to your project.

We will discuss about Scala community and we find a time for a free form talk!

Workshop: Exploring parallel programming in Java

Wolf Schlegel

Download slides

One-line description

Using Java 7's fork-join framework to develop multicore-friendly software

Session format

Tutorial (180 mins)


In order to gain performance improvements from multicore processors, software needs to use multiple threads or multiple processes. With the fork-join framework, Java 7 introduces an addition to the Java concurrency package that supports parallel programming in Java.

When developing software using a parallel framework, the resulting design is likely to differ from a solution that has been developed in a single-threaded style. This session explores how parallel programming affects the design of software. It also allows participants to reflect on the impact of parallel programming on unit testing and test driven development.

After an introduction into the new concurrency classes coming with Java 7, participants work on three exercises. One of the exercises is about refactoring an existing single-threaded design to take advantage of the fork-join framework.

Audience background

Participants should have a working knowledge of Java and come along with Java 7 installed on their machines.

Benefits of participating

Participants will gain hands-on experience with Java's new fork-join framework and understand its impact on unit testing and test driven development.


After an introduction into the new Java concurrency classes, participants form small groups or pairs to explore the exercises collaboratively.

Detailed timetable

00:00 - 00:30 : Introduction into Java 7's fork-join framework

00:30 - 01:00 : Installing Java 7 and the exercises

01:00 - 01:45 : Exercise 1

01:45 - 02:00 : Break

02:00 - 02:45 : Exercise 2

02:45 - 03:00 : Participants discuss their solutions and share observations

Workshop: Git

Matthew McCullough

You've heard about Git, Mercurial, Bazaar and the Distributed Version Control System revolution. In this deeply hands on session, we'll load Git on participants laptops, build repositories and share out pieces of work. We'll explore the optimized agile workflows that Git facilitates, building branches for each story card and merging with our team mates, even when a network isn't present. We'll explore the incredibly polished interoperability of this radical source code control tool in a hands on session and requires attendees to bring a laptop (Windows, Linux, or Mac).

Workshop: Java EE 6 = Less Code + More Power

Arun Gupta

The Java EE 6 platform allows you to write enterprise Java applications using much lesser code from its earlier versions. It breaks the “one size fits all” approach with Profiles and improves on the Java EE 5 developer productivity features. Several specifications like CDI, JSF 2, JAX-RS, JPA 2, and Servlets 3 make the platform more powerful. It also enables extensibility by embracing open source libraries and frameworks such that they are treated as first class citizens of the platform. This hands-on lab will explain the Java EE 6 key concepts and specifications using NetBeans and GlassFish.

Training: Android Development

Lars Vogel


2-day course


999 PLN + VAT (300 EUR + 23% VAT)


Learn in 2 days all important concepts and techniques to develop Android apps. Lars Vogel is an experienced Android trainer and publishes popular Android tutorials on http://www.vogella.de.

Agenda Day 1

Architecture of Android

  • Concept
  • Devices, Emulator and Images
  • Installation and usage of ADT
  • Android Manifest
  • Resources

Intents and Activity Communication

  • Intents
  • Activities / ActivityStack
  • Views / Layouts
  • Interaction with Buttons & Co
  • ListView
  • Concept


  • Adapter
  • ListActivity

File based Persistence

  • Preferences
  • Files, Access restrictions


  • Androids Security Concept
  • Permissions / Uses Permissings


  • Apache HTTP Client
  • REST
  • JSON
  • XML


  • Multitasking and Network Access with AsyncTask
  • Handler

Agenda Day 2

SQLite & ContentProvider

  • Datenbank (SQLite)
  • ContentProvider

Services, Receivers and Notifications

  • Services
  • Registration of a broadcast receiver
  • Using Notifications
  • Using Services

Screensizes and Canvas

  • Screen sizes and densities
  • Own Views with Canvas

Location Based Service Applications

  • Location based Services
  • Integration of Google Maps
  • Karten-Overlays
  • Geocoding / Reverse Geocoding
  • Usage of GPS, Wifi, ...

Homescreen Widgets

  • UI Restrictions, RemoteViews
  • Widgets
  • Refresh

Advanced Topics

  • Push Notification
  • Server Storage


  • Deployment
  • Markets
  • Version Management

Training: Clean Code

Robert C. Martin


2-day course


2490 PLN + VAT (700 EUR + 23% VAT)


Even bad code can function. But if code isn't clean, it can bring a development organization to its knees. Every year, countless hours and significant resources are lost because of poorly written code. But it doesn't have to be that way?

In this two-day Clean Code Workshop you will learn the principles and practices of Clean Code as described in Robert C. Martin's book:

Clean Code: A Handbook of Agile Software Craftsmanship.

This Clean Code course alternates between lecture and exercise so that you can experience, first-hand, the practices and disciplines of these fundamental topics.


  • Professionalism, Craftsmanship, and Clean Code.
  • Choosing Meaningful Names
  • Writing Clean Functions
  • The Proper Use of Comments
  • Coding Style and Formatting
  • Object Oriented Programming vs. Procedural Programming.
  • Error Handling
  • Boundaries between Subsystems
  • Unit testing, and Test Driven Development
  • Writing Clean Classes
  • Systems
  • Plan vs. Emergence
  • Concurrency
  • Smells and Heuristics.


This course is for Java/C#/C++ developers who want to improve their ability to contribute to their company and their team by writing better code.

Learning Outcomes

  • An attitude of professional craftsmanship.
  • How to tell the difference between good and bad code.
  • How to create write good code and transform bad code into good code.
  • How to create good names, good functions, good objects, and good classes.
  • How to format code for maximum readability.
  • How to implement complete error handling without obscuring code logic.
  • Effective unit testing and refactoring techniques.


This is an exercise driven course. Each topic is driven home through the use of hands-on exercises in which the students must work together to write new code, or alter existing code to resolve, enhance and improve the quality of the code.


Must know Java

Course Materials

  • Course lecture slides, notes and additional reference materials.

Topics Day 1

Clean Code

  • There Will Be Code
  • Bad Code
  • The Total Cost of Owning a Mess
  • The Grand Redesign in the Sky
  • What is Clean Code?
  • A review of expert opinions.
  • Schools of Thought
  • The Boy Scout Rule

Meaningful Names

  • Use Intention Revealing Names
  • Avoid Disinformation
  • Make Meaningful Distinctions
  • Use Pronounceable Names
  • Use Searchable Names
  • Avoid Encodings
  • Avoid Mental Mapping
  • Class Names
  • Method Names
  • Don’t be Cute
  • One Word per Concept
  • No Puns
  • Solution Domain Names
  • Problem Domain Names


  • Small!
  • Do One Thing.
  • One Level of Abstraction
  • Switch Statements
  • Function Names (again).
  • Arguments and Parameters
  • Side Effects
  • Command Query Separation
  • Exceptions
  • DRY – Don’t Repeat Yourself.
  • Structured Programming


  • Why and When to Write Comments
  • Explain Yourself in Code
  • Good Comments
  • Bad Comments


  • The Purpose of Formatting
  • Vertical Formatting
  • The Newspaper Metaphor
  • Horizontal Formatting


Topics Day 2

Objects and Data Structures

  • Data Abstraction
  • Data/Object Anti-symmetry
  • The Law of Demeter
  • Data Transfer Objects

Error Handling

  • Use Exceptions not Return Codes
  • Write your try/catch Statements First
  • Use Unchecked Exceptions
  • Provide Context with Exceptions
  • Define Exception Classes for Callers
  • Define Normal Flow
  • Don’t Return Null
  • Don’t Pass Null


  • Using Third Party Code
  • Exploring and Learning Boundaries
  • Learning Log4J
  • Learning Tests are Better than Free
  • Using Code that Does Not Yet Exist.
  • Clean Boundaries

Unit Tests

  • The Three Laws of TDD
  • Keeping Tests Clean
  • Domain Specific Testing Language
  • One Assert
  • F.I.R.S.T.


  • Class Organization
  • Small Classes
  • The Single Responsibility Principles (SRP)
  • Maintaining Cohesion
  • Organizing for Change

Smells and Heuristics

  • Dozens and dozens of them.


Training: Domain Driven Design (Polish)

Sławomir Sobótka


2 dni


1490 PLN + VAT (430 EUR + 23% VAT)


wykład, warsztaty, dyskusja


programiści, projektanci, architekci


Szkolenie prowadzone jest w formie, która łączy następujące po sobie na przemian wykłady, warsztaty i dyskusje.

Podczas wykładów trener prezentuje kolejne rozdziały wiedzy merytorycznej, uzupełniając je o komentarze na podstawie własnych doświadczeń.

Podczas warsztatów tworzymy dwa moduły systemu lasy ERP. Kolejne zadania polegają na przyrostowym dodawaniu nowych funkcjonalności w sposób ilustrujący zagadnienia teoretyczne poznane podczas poprzedzającego je wykładu.

Podczas dyskusji uczestnicy mają dostęp do wiedzy eksperckiej trenera oraz mają możliwość zweryfikowania swoich rozwiązań z wypracowanych przez innych uczestników szkolenia.

W czasie warsztatów uczestnicy rozwiązują postawione przed nimi problemy pracując w parach (Pair Programming), zmieniając po każdym zadaniu role: Pilot i Driver. Technika ta ma za na celu umożliwienie spojrzenia na zagadnienia z różnych perspektyw, aktywując jednocześnie więcej zasobów kognitywnych.

W ramach szkolenia omawiamy oraz ćwiczymy w praktyce zarówno podstawowe jak i zaawansowane techniki DDD, takie jak: wzorce Building Blocks, wypracowanie Ubiquitous Language oraz zestaw technik Strategic Design.

Przed szkoleniem zapoznaj się z projektem ilustrującym techniki DDD i CqRS: http://www.bottega.com.pl/ddd-cqrs-sample-project

Szczegółowy program szkolenia.

Training: Management 3.0: Agile Leadership Practices

Jurgen Appelo


2-day course


1490 PLN + VAT (430 EUR + 23% VAT)


course materials (English)
book Management 3.0 (English)


Agile management is an often overlooked part of Agile. There is much information available for Agile developers, testers, and project managers, but very little for development managers and team leaders. However, when organizations adopt Agile software development, not only developers, testers, and project managers need to learn new practices. Development managers and team leaders must also learn a new approach to leading and managing Agile organizations.

Several studies indicate that “old-style” managers are the biggest obstacle in transitions to Agile software development. Development managers and team leaders need to learn what their new role is in Agile software development organizations. This course is designed to help them.

Target Audience

This course aims at leaders/managers who want to become Agile, and people who want to become great team leaders or line managers. (No practical experience with Agile methods is necessary, though some familiarity with Agile principles and practices is useful.)

The course typically draws team leaders (15%), development managers (15%), agile coaches (15%), scrum masters (15%), project managers (10%), product owners (10%), developers and testers (10%), and top-level management (10%).

Topics Day 1

  • Agile software development is the new golden standard for software teams. You will learn about different Agile methods, popular best practices, the 7 dimensions of looking at software projects, challenges in Agile adoption around the world, and the contribution of the manager and team leader in Agile organizations;
  • Complexity science and systems thinking are the cornerstones of an Agile mindset. You will learn about causal loop diagrams, what complexity theory is, how to think in terms of systems, about Black Swans and Jokers, about the difference between complex and complicated, and about the 7 fallacies we often recognize in traditional linear thinking;
  • People are the most important parts of an organization and managers must do all they can to keep people active, creative, and motivated. You will learn about the difference between extrinsic vs. intrinsic motivation, the 10 intrinsic desires, and common techniques for understanding what is important to the people in your teams, such as one-on-one meetings, personal assessments, the 12 most important questions, and 360 degree meetings;
  • Teams are able to self-organize, and this requires empowerment, authorization, and trust from management. You will learn how to make self-organization work, how to distribute authorization in an organization, the challenges of empowerment, how to grow relationships of trust, and several techniques for distributed control, such as the 7 levels of delegation, and authority boards;

Topics Day 2

  • Self-organization can lead to anything, and it’s therefore necessary to protect people and shared resources, and to give people a clear purpose and defined goals. You will learn when to manage and when to lead, how to use different criteria to create useful goals, about the challenges around management by objectives, and how to protect people and shared resources from any bad effects of self-organization.
  • Teams aren’t able to achieve their goals if team members aren’t capable enough, and managers must therefore contribute to the development of competence. You will learn about skill levels and discipline levels, how and when to apply the seven approaches of competence development, how to measure progress in a complex system, the effect of sub-optimization, and several tips for useful metrics;
  • Many teams operate within the context of a complex organization, and thus it is important to consider structures that enhance communication. You will learn how to grow an organizational structure as a fractal, how to balance specialization and generalization, how to choose between functional and cross-functional teams, about informal leadership and widening job titles, and about treating teams as value units in a value network;
  • People, teams, and organizations need to improve continuously, in order to defer failure for as long as possible. In practice this means that managers and leaders must act as change agents, trying to change the social complex systems around them. You will learn about the 4 facets of change management, which address the system, the individuals, the interactions, and the boundary of the system.

Games and Exercises

Each of the eight topics includes at least one game or exercise where people put into practice the ideas of the course in groups of five or six people. Sometimes the attendees play as different managers against each other. Sometimes they act together as one manager, sharing their thoughts while working on a problem.

Every social activity ends with a debrief and a discussion, so that people can relate what they've learned to their own situation, and bring up questions and experiences to be addressed by the whole group.