It was an intense, fun and interesting week. The content was there as usual, but there was especially a good vibration about things to come.
There were three big themes this year: java8, client-side programming and the internet of things.
Java8 is coming
In March 2014 the next version of Java will be released. I think this is one of the most important new Java releases ever, on par or even more important than Java 1.5.
The major and most discussed new feature is the introduction of lambda expressions (formerly known as closures). This allows a functional style of programming. This was already possible in many cool languages like Scala, Groovy and Ruby. While you could more or less do functional programming already using anonymous inner classes, the new syntax makes this much more practical to use (less verbose) and introduces compiler and JVM-level support which also makes this more efficient in some cases.
There are many other improvements which have a lesser impact but are also very nice:
- default methods on interfaces. This allows default implementations to be added on methods in an interface. This way, interfaces in an API can be extended without causing compilation failures. It also gives compared to traits or mixins in other languages and said to give multiple inheritance of behaviour.
- Optional type. This gives us a way to clearly indicate that methods may accept or return null using the type system. When consistently applied, it avoids unnecessary checking for null.
- new date and time handling. The java.util.Date class was known to be flawed for a long time, and I guess many teams did themselves a favour by using alternate classes for date handling. There is now an official better way, influenced by joda-time. I am not sure people will move away from joda-time, it it still way more convenient for example with easier conversion with java.util.Date and toString() with a format.
I personally feel that Java8 brings the Java into the 21st century. I my book, it strongly reduces the lure of newer languages like Groovy and Scala and reinforces my conviction that Java is highly recommended for server-side development.
There were a few talks which were oriented towards other languages in which Java was ridiculed for only introducing lambda expression now saying, “xxx had lambda expressions from day one”. It is obviously easy to bash, but I am personally happy to see that the Java community takes sufficient time to trade-offs of different ways of introducing new features. The backwards compatibility of the language is one of the most important features which allows enterprise development where software is used and needs to be supported for a long time (10+ years). It is comforting that Java and many of the important Java libraries give us the support to keep maintaining these projects and allow us to still migrate to more recent versions. There are few programming environments which allow this kind of long time support.
I love the improvements in Java8 and am already using it for some new projects.
Internet of things
Devoxx does a great job making us aware that more and more devices will be connected and to help us to be ready for this. There was a shop at the exhibitors hall where Raspberry Pis, Arduinos and various robots could be bought. There was also a company showcasing the amazing Nao robot. I have to admit, I could not resist myself and bought a spider robot (a hexapod robot kit).
There were hands-on sessions with Raspberry Pis and Arduino systems, there were a couple of session about using (and even building) devices like quadcopters and others. There will be a lot of people working on all kinds of robots or embedded systems in the years to come, so it makes sense to get acquainted with the technology already.
Innovation is also enabled by this. It is again possible for a small group of enterprising people (or just one) to come up with solutions and build and commercialize them. With some help from standard hardware boards, 3D printers and factories which build low volumes of custom objects. Very exciting and a lot of fun.
There were also more down to earth session. I likes Matt Raible’s talk with advise. Don’t agree with all of it, but an interesting opinion. There was a very nice refactoring talk which also showed IntelliTest. Not sure if I can use that in the projects I am working on, but definitely worth keeping in mind.
On the tooling front, I was impressed with FluentLenium. This really seems to be a step forward and seems to integrate nicely with FEST assert. I will start using that soon. I was very pleased (shameless self-plug) to be able to give a quickie about jTransfo. There was a good audience and many questions.
The was also a mind boggling talk about the Java Microbenchmark Harness and the pitfalls of benchmarking. It is mind-boggling to see how intelligent (or maybe not) both processors and the JVM/JIT are and what kind or strange results this can cause when benchmarking.
This year was one of the best Devoxx editions. If you missed it, you can already mark the week of November 10 2014 to join me for the next edition.