In the previous post I’ve described the "GeeCON Buzzwords" approach - have a look if you’ve missed it: GeeCON Reactive 2016 - in Sopot this September

Now, it’s high time to do a deeper dive into the agenda.

Reactive Streams

We are starting with the Reactive Streams (the manifesto, TCK etc). I’ve described it in the previous writeup; the Reactive Streams intention is to provide a standard for asynchronous stream processing with non-blocking back pressure. We decided to drill down multiple aspects of that:

  • describe what’s all about in plain English

  • cover the TCK, the technology compatibility kit, which offers a set of tests to validate implementation against Reactive Streams rules. This is effectively a place where all the edge cases and shaded corners are covered.

  • show a bigger picture how going reactive can impact the application architecture

Is it only for new stuff?

You might have though this reactive thing is only for new, green field, development. That’s not true and we (obviously) have an answer to that.

One thing to cover would be reactive extensions (Rx), which is not Reactive Streams per se (not until the version 2.0), but it’s an important library in the reactive family. We have an honor to host Tomek Nurkiewicz, who will cover RxJava in the way he does it in most of his presentations: a single title slide and live coding. Tomek is currently writing a book about RxJava for O’Reilly - which is a great recommendation itself.

Besides RxJava, reactive is coming to one of the most popular frameworks in the JVM world - Spring Framework. Spring 5.0 (which first milestone has just been release - as of writing these words) will be inherently reactive, based on Pivotal’s implementation of Reactive Streams: Project Reactor.

To bring some more light how things might work inside a reactive engine and what are the implications for the application developers - we’ve asked Stephane Maldini - project lead of the Project Reactor - to share some expertise with you. Probably there is no better person to give you first hand information what can be expected in Spring ecosystem. Probably must watch if you are working currently with Spring Framework.

Beyond the server side

Reactive disrupts the server side - but it’s not only server side programming that needs changing. It’s obviously important for the backend to be able to handle enormous throughput of data, but also other parts of the system (storage, frontend) needs adequate adapting. We are covering this as well.

First and foremost, we will looking into web frontends. "Functional reactive web" - which is a promise given by Elm. A language designed around a concept of pure transformations of data that operate on messages coming in and modifications to the HTML going out. This will be brought to you by Samir Talwar. We didn’t want to go JavaScript (again) nor take general purpose language which has a JS runtime (Scala, Kotlin etc). We wanted something that was built with a web in mind. Elm seemed to fulfill this definition.

Frontend, however, doesn’t mean only web. It can be a mobile application as well. That’s why we are bringing practitioners from codewise with examples and use cases of implementing 100k transaction per second, with extensive usage of RxJava (on the server side) and reactive mobile applications (for consumers' frontends).

The closing keynote: haven’t we seen all that?

Last year we’ve given you a closing with a twist. Erik Dörnenburg gave a great keynote, letting us ponder a bit what’s the role of an architect, especially in the microservice world. World of small teams, collaboration, empowerment and completely different decision making processes.

This year, we asked Kirk Pepperdine to give us some final thoughts. When I first met him few conferences ago I was impressed by his experience. When I attended his Smalltalk quickie (GeeCON 2016) I though - Wooow! This guy saw nearly everything ;) When we’ve spoken later about the idea behind GeeCON Reactive, about the current state of industry, buzzword, containers, all that stuff - it occured to me Kirk has done it all in mid-nineties.

Obviously, back in nineties, reactive wasn’t standardized, it was proprietary. Still - very powerful and incredibly efficient. We don’t want to reinvent the wheel, we believe best is achieved when we stand on the shoulders of giants. That’s why we asked Kirk to share his past experience, tell some good stories, show things to learn from - to avoid repeating same mistakes.

You can expect it in his closing keynote: "MicroServices - Old Fish, New Fish".


Well, don’t think twice, just go and register - with the early birds price (until 11th of August). And finally grok the concept of reactive programming!