Devoxx 2015

On 10, 11 and 12 November, the yearly Devoxx Belgium conference took place in Kinepolis Antwerp. With 3500 attendees, 8 tracks and over 200 speakers, this is the biggest Java Community conference of Europe. Of course, it is not only about Java, but all JVM languages are covered, including (of course) Scala and Clojure. Also related technologies, like frameworks, development methodologies and best practices regarding deployment, architecture and testing are covered.

Because of the size of the conference, you have to make a lot of choices. Originally, I wouldn’t go alone, but unfortunately the conference was sold out well in advance, which caused that in the end I was the only one able to get a ticket. The good news is that all sessions were recorded and are available on YouTube for free.

Main topics

As already mentioned, there where 8 tracks with 7 slots per day, which results in a large number of talks. Despite that I think a couple of topics which were more covered than others and they more or less align with the current trends in the software development world, and more specific in the JVM community.

• Java 9/10
  • Modules
  • JShell (REPL)
  • Additions to Collection API
• Microservices
  • Resilient software design
  • Deployment best practices
  • Chaos testing
• Functional Programming Paradigms and Reactive Programming
• IoT (Internet of Things)

Java 9

Mark Reinhold, Chief Architect of the Java Platform, did the opening Keynote of Devoxx. It was (of course) all about Java 9 and mainly the modularization of the language they are planning to do. After the keynote, there were a number of sessions on the various aspects of this change, covering from how they implemented it to how to use it in practice. I didn’t attend all those sessions, because 7 years ago they did saying it would appear in Java 7, which eventually didn’t. The requirements have changed quite a bit since then and the implementation with it as well. For example, they removed support for versioning of modules, because it became too complex and it would be really complex to make it work with existing tools, like Gradle and Maven, as well. At the time, the modularization was mainly inspired by JavaFX at the time, which is now less relevant as well. The main reasons for modularization are:

• More scalable for small devices (think IoT)
• Improve security and maintainability (it is possible to actually remove unused parts… Corba!)
• Improve performance

This talk is also on Youtube.

Java 9 is expected next year and next month the current development version should be feature complete. Mark Reinhold and Alan Bateman did a large number of sessions on the modularization of Java and how to prepare your application for it:

• Prepare for JDK 9! by Mark Reinhold/Alan Bateman
• Introduction to Modular Development by Mark Reinhold/Alan Batema
• Modular Development with JDK 9 by Mark Reinhold/Alan Bateman
• Advanced Modular Development by Mark Reinhold/Alan Bateman
• Project Jigsaw: Under the Hood by Mark Reinhold/Alan Bateman

Besides modularization, Java 9 will contain a REPL, called jshell which was presented by Robert Field and an improved API for collections, mainly for creating new collections, presented by Stuart Marks. Java 9 will also include support for HTTP/2. Simone Bordet did a talk on HTTP/2 which was interesting to see. HTTP/2 will result in the same speed gain as the SPDY protocol, but is better supported by browsers. It will also give improvements for server-to-server communication. To benefit optimal from HTTP/2, you should integrate it in your app logic to indicate which resources are belonging together. The latest versions of Jetty contain already support for HTTP2.

Second Keynote

There was a second keynote by Dr. Lawrence Krauss, a theoretical Physicist, about the creation of the universe. This was very interesting, and can also be found on Youtube.

Microservices

I’ve attended a couple of sessions on Microservices. The most interesting one in my opinion was the session of Sam Newman, author of the book ‘Building Microservices’ published by O’Reilly. His talk focussed on 8 principles for designing Microservices:

• Modelled Around Business Domain
• Culture of Automation
• Hide Implementation details
• Decentralize all the Things
• Deploy Independently
• Consumer First
• Isolate Failure
• Highly Observable

It is a bit too much to go over detail for ever principle, but relevant things for us to mention are:

• Hide implementation detail: Hide your database, services shouldn’t share a data model.
• Decentralize all the things: He discussed a concept called ‘the magical mystery bus’ which is a central communication bus which has a lot of knowledge on how message should be handled.
• Consumer first: Many organizations deploy all the services together, because they are tested together. To fix that problem, you should do consumer based testing: identify what the consumers of a service do and make that into a contract. Tools for doing that are for example Pact.
• Isolate failure: It is easy to create a ‘distributed single point of failure’ when building a Microservice based application. Solutions: reasonable timeouts, bulkhead downstream connections and circuit breakers.

A related talk to this was by Jonas Bonér: Without resilience, nothing else matters. This was about how to create resilient software. The basic idea of this session was based on the design principles of Erlang, which is that it should be able to crash without causing data to be corrupted. He proposed the use of a supervisor to manage the individual parts of the system which perform the critical operations. Those modules should be abel to crash safely and start quickly, which means they should be as stateless as possible.

Lorin Hochstein, an engineer at Netflix, continued on this topic by explaining how Chaos Testing is part of the development culture at Netflix. Familiar to most people is probably the Chaos Monkey, which takes out services and other parts of the Netflix infrastructure to test resilience, but he also explained another new testing method at Netflix which is called ‘Chaos Kong’. Chaos Kong does not just kill a single service, but periodically takes down an entire datacenter. We do this of course as well, but he emphasize that automating these kind of tests make it something which is on top of mind of the engineers. He also talked a bit about the general development culture at Netflix. Interesting points he made regarding their testing and deployment of services. Since their entire architecture consists of a very large number of services, it is impractical to have it running on a ‘development environment’, so they don’t test end-to-end before release. Instead they have detailed monitoring on everything. The main metric to see if systems are healthy is visualized in a graph displaying the number of started streams. This should consistent over the weeks and a deviation from previous weeks indicate some malfunction of a service. If this number is influenced, it means there are serious issues. He recommends for each business to have something similar to monitor the health of production systems. He also pointed out the only way to ‘visualize’ their architecture is by generating a diagram. It is too complex for a single engineer to keep all the services and all their connection in his head.

Another relevant session in this area was The Twelve Factor app: Best Practices for Java Deployment by Joe Kutner which discussed how to deploy services.

1. Codebase
2. Dependencies
3. Config
4. Backing services
5. Build, release, run
6. Processes
7. Port binding
8. Concurrency
9. Disposability
10. Dev/prod parity
11. Logs
12. Admin processes

Functional Programming paradigms

Java 8 introduced Lambda’s and closures. For many developers this is a whole new paradigm with which they are not really familiar. Venkat Subramaniam did a session on how some of the Design Patterns described in the famous ‘Gang of Four’ book with Lambda’s, reducing the amount of boilerplate significantly. It was interesting, probably doesn’t contain a lot of new concepts for Scala developers, but very nice to see nevertheless. The same presenter also had a session during the Unversity days on Core Design Principles for Software Developers which is very nice to see.

Other talks

Of course there was a lot more I saw.

• How to stop wasting your time and start performing useful code reviews. I didn’t think this was a very interesting talk, but it has some nice points.
• The never-ending REST API design debate by Guillame Laforge
• Life of a Twitter JVM engineer: the garbage keeps coming… by Tony Printezis
• The Silver Bullet Syndrome

Below some pictures on the optimisation achieved with HTTP2. The example consists of a Jetty:// logo build from a number of small images. In the first image you see the load time without HTTP2 and in the second image with HTTP2

This entry was posted on Thursday, November 26th, 2015 at 11:42 and is filed under English. You can follow any responses to this entry through the RSS 2.0 feed. Both comments and pings are currently closed.