by Logo Technical Blog – Future Processing
Arkadiusz Kawka
Daniel Kostrzewa
Mateusz Chrobok
Piotr Wittchen
Michał Perczak
Marek Ozaist
Tymoteusz Rogowski
Devoxx Conference summary

This year, for the first time the Devoxx conference was held in Poland. There were plenty of lectures and experts to learn from. Below, a short summary of the lectures we found the most interesting.

Apache Cassandra 101 (Christopher Batey)

One of the most important topics of the Devoxx Poland 2015 was databases. Among many interesting talks was the lecture on Apache Cassandra given by Christopher Batey.

Christopher began his talk with short introduction and motivation about reasons of switching Oracle to Cassandra.

The main part of Christopher’s lecture was about how Cassandra is actually working. He told us about data dispersion between available nodes of database cluster, replication methods and consistency levels, which are available in Cassandra database.

The lecturer also mentioned that data stored in Cassandra should be modelled in a different way than it is in standard relational database. This data must be denormalized and stored as big tables because Cassandra does not allow both joins and aggregate functions. As a result Cassandra developers created new Cassandra Query Language to handle such a data store.

In my opinion, the lecture given by Christopher was one of the best during the whole Devoxx Conference. The speaker introduced Cassandra database and some of its internals. The talk was very informative and well organized. It was a pleasure to attend such a good lecture.

Daniel Kostrzewa

Lazy Evaluations (Venkat Subramaniam)

Venkat was one of the keynote speakers on Devoxx. He gave a few lectures about some flavours of Java 8 features. During one of the lectures he was speaking about lazy evaluations in Java.

Firstly, Venkat introduced reasons why sometimes evaluations should be postponed. He also showed methods and Java 8 language constructions to do it. However, live-coded examples were the main part of his lecture. That examples mainly focused on Java 8 streams, which allows to evaluate methods in a lazy manner.

In my opinion, it was the best speaker and the best lecture of Devoxx Poland 2015. That speach was literally brilliant and extremely funny. The last sentence of the lecture was the best way to summarize it: “Be very eager to learn how to be lazy”.

Daniel Kostrzewa

Deep dive into Reactive Java (Tomasz Kowalczewski)

“Reactivity” was probably one of the most popular words during this year’s Polish edition of Devoxx conference. This subject was raised up by many lecturers, and one of them was Tomasz Kowalczewski. His presentation titled “Deep dive into Reactive Java” was a smooth introduction to the world of reactive programming in Java.

The slides were the first part of his speaking. Tomasz talked about history of reactive programming and basic concepts, such as extended observer pattern. Comparison between synchronous and asynchronous design was also shown and some problems (timeouts, back pressure, error handling) related to the former one were described.

The most important part was the second one which was performed as live-coding. All examples were written using RxJava library. Tomasz was trying to introduce the most important methods from API one by one. Each of them was described in details. Subsequent examples were gradually more complicated.

There were some additional positive aspects which made his presentation more interesting. I really liked the way he was presenting his thoughts. They were clear and understandable. The slides were only an addition – most valuable part was performed as live-coding. Moreover, all instructional materials were immediately published on Twitter.

Personally, I found that lecture as one of the most interesting ones during this year’s Devoxx. However, some participants may claim that it wasn’t as “deep dive” as they would expect. Nevertheless, for those who are new to the world of reactive programming it was a good place to begin journey with that programming concept. I was one of them and I think it was really inspiring to the extent that I’m constantly trying to expand my knowledge in that field.

Mateusz Chrobok

React.js: Super-fast Single Page Web Applications (Pratik Patel)

One of the lectures which I was mainly awaiting was Pratik Patel’s presentation titled “React.js: Super-fast Single Page Web Applications”. His speech was presented in a form of tutorial. Only basic things and concepts were presented, however the vast majority of participants were not familiar with React.js and provided facilities.

The presentation consisted of slides and live-coding, which were used alternately. The slides were pleasing to the eye. Most of them were focused on virtual DOM, which is one of the reasons why React.js is so fast in comparison to other frameworks.

On the other hand, during live-coding Pratik was trying to show how to create and link components in React.js and how they interact with each other. He described passing parameters to such components and handling events in details.

At the end, Pratik briefly mentioned Flux architecture that is used by Facebook for building client-side web applications. He pointed out simplicity of that architecture, which is based on unidirectional data flow. It matters when application gets bigger and more complicated. I wish he could exhaust the subject more.

In my opinion, it was worth being part of that lecture. I knew some things about React.js but it extended my knowledge a little bit and provoked to learn more. The lecture was well prepared and touched upon subjects I am interested in.

Mateusz Chrobok

Get Past the Syntax, The Real Scare is in the Semantics (Venkat Subramaniam)

Dr. Venkat Subramaniam presented an interesting point of view during his talk at Devoxx conference. Programmers, who start learning a new language, often complain about syntax. They focus on using available keywords and constructions instead of trying to understand their meaning and purpose. Programmers also have their own habits. That’s why Java has similar syntax to C and C++. Creators of Java designed new language with syntax, which was familiar to them, with significant improvements. Perception of the world is based on experience and things we get used to. The same rule applies to programming languages. Most software developers are familiar with imperative programming paradigm. They often focus on describing computation in terms of statements and changing program state. This approach leads us to necessity of creating a lot of temporary variables and boilerplate code. Let’s have a look at the following code snippet:

int start = 0;
int limit = 10;
int i = start;
int j = 0;
int[] evenNumbers = new int[limit];
double sum = 0;

while (j < evenNumbers.length) {
  if (i % 2 == 0) {
    evenNumbers[j] = i;

for (int k = 0; k < evenNumbers.length; k++) {
  sum += Math.sqrt(evenNumbers[k]);


This code prints sum of the square roots of the first ten even numbers starting from zero. It’s not so complicated task, but there is a lot of code, temporary variables, two loops, we have to be careful with operators to avoid ArrayIndexOutOfBoundsException and so on. Moreover, code is quite hard to analyze and we can make a mistake in many places. Let’s see what happens when we use functional programming approach, Java 8 with stream API and lambdas. We can do the same task in the following way:

int start = 0;
int limit = 10;

double sum = Stream
               .iterate(start, e -> e + 1)
               .filter(e -> e % 2 == 0)
               .reduce(0.0, Double::sum);


As we can see, the code is simpler, cleaner and easier to analyze. The only difference is the fact that we changed approach from imperative to the functional one and applied different semantics. In this case, instead of focusing on how to do the task, we focused on the result we want to obtain. Instead of learning only syntax, we should spend more time on learning semantics to understand its purpose. This will allow us to create better and robust solutions in less time.

Piotr Wittchen

Microservices - enough with theory, let's code some (Tomasz Szymański, Marcin Grzejszczak)

Microservices - enough with theory, let's code some - when I read the title of this lecture I already knew I have to take part in it. In the past, I participated in a few conference discussions (JDD, Geecon) which explained only theory of microservice architecture. I still felt lack of real examples and on Devoxx my expectations were satisfied. The lecture was presented by Tomasz Szymański and Marcin Grzejszczak, who are very experienced developers.

Guys presented a sample application which simulated beer brewing process in a small brewery. Application used REST microservices. Tomasz and Marcin shared with the audience their experience about building microservice systems and mentioned a few important things which you should remember when you build a microservice system e.g. they paid attention to versioning REST API, which is very important.

However it was only one part of discussion. For me, the most interesting part was a proposal of full stack architecture which allows building, preparing and maintaining applications based on microservice architecture. Tomasz and Marcin presented great solution, which contains only open source software. Microservices were developed under Java 8, ELK stack (Elasticsearch, Logstash and Kibana) was used for logging and of course Jenkins for CI couldn't be missed.

Very surprising and interesting for me was their approach to error notifications, which used Slack. It’s very original solution. Apache Zookeeper was used for service discovery and Icinga for health check control. Swagger was used for documenting REST API. This presentation showed me how to design good architecture of microservices systems and, at the same time, increased my awareness about it.

Summing up it was great one hour for me. Discussion was very interesting and gave me new knowledge for the future. I’m sure that I’ll use this knowledge in new projects. Thanks guys, Great Job.

Michał Perczak

Ansible to rule them all (Rafał Piotrowski, Wojciech Podgórski)

Ansible is a tool used for simple environment provisioning and applications deployment. You write scripts in YAML, which you can run on remote servers by SSH (you don’t need to run any Agents).

The presentation showed how to use Ansible to install Apache Tomcat servlet container on application servers and deploy simple Java application build upon Spring Boot. Network traffic is routed and balanced using HAProxy software load balancer, which is installed on load balancer server.

Ansible has many advanced features: playbooks, tasks, modules, variables, templates, roles, handlers or decrypting passwords. With these features it is really easy to write script to install and configure JRE, Tomcat, HAProxy and invoke it on any machine.

Rafał and Wojciech also mentioned that tasks should be idempotent so that they don’t have any additional effect if it is called more than once.

Marek Ozaist

Functional Data Storage (Greg Young)

During the presentation Greg Young introduced the audience to the idea of using huge containers as infrequently as possible, as they do everything except what we expect them to do. Greg was focused on functional approach to maintain the whole application, and showed that event sourcing related to functional paradigm must not depend on any framework. He showed a common use case where we have some repository, some driver,variable number and types of dependents for each method we need to support, as the base for presentation. He successfully managed to refactor all this stack as functional code. Then he made people impressed by showing how easy it is to introduce an immutable operation of change, like an ‘add new order line in order’, by creating some flow rules. That operation provided the event sourcing pattern into code without using any framework. The presentation was very good however, for me, using sublime as an editor is weird, maybe because I like using IntelliJ IDEA. The most important thing for this talk was the slogan “You do not need an Event Sourcing Framework, it’s already implemented by functional programming”.

Mateusz Odelga

From Docker To Kubernetes: A Developer's Guide To Containers (Marek Grabowski)

If you heard about Docker (maybe even used it) and the need for containerization but wondered how docker fits in the big picture of modern system architectures such as micro-services and the cloud, then this talk was definitely the place to be at this year's Devoxx.

In the first part of the presentation Marek gave a recap on what Docker is and how it works. Interesting insight here was that docker is heavily built on cgroups, namespaces, capabilities and chroots;concepts and tools that have been existing in the Linux world for quite some time.

Next, he gave us a quick tour of the Google Cloud Platform and Google Container Engine (GCE) and how Docker is used there and internally at Google. He mentioned how they are moving away from bare-metal and VM solutions into container-based solutions. Google is running hundreds of thousands, if not millions, of containers 24/7, both as a part of GCE and their internal solutions so that a concern sprung into my mind if it wouldn’t be better price and performance-wise to stay bare-metal. Marek promptly dispelled my doubts by sharing that Docker along with Kubernetes provided tremendous maintainability and manageability advancements in their solutions that far outweigh performance and price concerns.

Marek also proposed an important paradigm shift for working with containers at bigger scale, which he called “from pet to cattle” - instead of managing pets, our containers, on a one-by-one basis we should treat our clusters of containers uniformly,- as a worker pool where you expect a single instance to die unexpectedly and be replaced with a new one. When you work at such scale you should be able to declaratively specify a cluster of docker nodes and its purpose and leave the load balancing, failover, workload management and discovery to an orchestration framework such as Kubernetes. As the old saying goes “If you feel the need to SSH into one of your containers you're most likely doing it wrong”. Thinking about your system architecture in such a way brings great scalability and manageability advancements down the stream.

Finally, Marek reiterated Google's want to share the knowledge and experience gained in working with containers and invited us to visit I know I will, as this talk has certainly whetted my appetite.

Tymoteusz Rogowski

Case Study: Agile (Matt Harasymczuk)

The talk given by Matt was a nice example of how changing an organization can be difficult but still possible. Matt focused on the approach taken during introduction of Scrum into government projects. At the beginning, it sounded a bit like sci-fi to me. My idea of this kind of projects was totally different and it was really nice to hear that things are going in a similar way as elsewhere. The important thing to remember – don’t throw everything at once – you may kill the change. Making small steps, with lots of coaching and explaining will get you better results. And that was the case with Matt’s transformation. Together with his team they’ve started slowly but pragmatically. Through things such as making Product Owners out of business analytics and educating them thoroughly, they’ve obtained POs that truly understand the meaning of this role. They were able to convert huge piles of documentation into product backlogs that can be refined together with development teams. Adopting good practices and tools such as github with gitflow, Sonar, Jira or regular code review, they were able to have a process that actually helps in development, making life easier and teams more productive. This also meant constantly delivering business value, the sole purpose of transformation.

Furthermore, Matt also shared with the audience some things that still require improvements – like public retros and dailies that could focus more on solving current problems. This was especially interesting for me, as learning from others enables you to avoid the same mistakes.

What is an important takeaway from Matt’s presentation is that we should adapt our approach basing on the situation we are given. If Matt had tried going all the way, throwing everything at the team at once, this would probably result in spectacular failure, given their context. And those few words I find as key ingredients when we think about organization transformation: think about the context then adapt and base your approach accordingly. For me, this wasn’t maybe something mind-changing, however I really liked the way Matt talked about his and his teams’ efforts.

Arkadiusz Kawka

Agile Development Meets Connected Devices - Lessons Learned (Michael Fait)

Michael Fait gave a talk about the project which involved tightly coupled software and hardware. For me, it was quite interesting to hear how to join those two worlds in the context of Agile. For Michael’s team the problems were a little bit different than the ones we are used to. In short, the project concerned super-coffee machine with customized software available also on mobile. At first, they had no device and struggled with any kind of development. It was difficult for the team to work with such abstraction so they asked for a prototype. This made it possible to, at least, start some tests and gather feedback. Later, they were able to get their hands on a device that resembled the final one a lot better. This made the work easier and more effective. Michael talked a lot about their approach to coding, quality and tests in overall. For example, continuous integration was a completely different thing than it is for most of us - basically, just another desktop with prototype of real device. It was really interesting to hear how agile can be adopted in a project in which you might wait up to a year for a machine to work with. Also what is important to me, Michael pointed out that Agile does not equal Scrum, it is not only about the process, having dailies, retros etc. It is important to remember why we are doing this the Agile way and what benefits we want to achieve. I tend to hear stories about the teams claiming to be Agile since they do sprints,plannings and retros. They sound a bit fuzzy to me and the example that Michael shown was different. For them, it was a conscious choice and seemed like a pretty good one.

Arkadiusz Kawka

Related Posts



This website stores cookies on your computer. These cookies are used to improve our website and provide more personalized services to you, both on this website and through other media. To find out more about the cookies we use, see our Cookies policy.