Here are my quick notes from this special event I attended on the 15th of May. It was a special event for several reasons.
The first one is it was the birthday celebration of the Paris JUG. Ten years already! For this occasion the guys from Paris JUG wanted to do something new.
And this leads to the second reason, the event happened inside the Eiffel tower. Even being Parisian and quite used to this monument, I have to admit it was thrilling to listen and discuss with Java geeks while having a huge panoramic view on the city.
The third reason explains why this post is written in English rather than in French. It’s because three of four talks were in English. Strange for a local French Java User Group? Well think global, act local, a Java story. :) More seriously, I think this is because one very special guest was not french speaking: Venkat Subramaniam. If you don’t know this man yet, check him out you won’t be disappointed. I call him the “live coding rock star”.
Maybe a fourth reason was the following cocktail, but unfortunately I couldn’t stay this late in the Tower.
Java 1 to 11 (Back to the Future… twice)
Rémi Forax made a retrospective of his personal history with Java. It was interesting because he knows and uses Java since its birth, and also because he is an academic, a known contributor (OpenJDK, ASM…) and also a JCP Expert (InvokedDynamic, Lambdas, Jigsaw).
It was a nice time travel, with a sample code evolving during the talk in its syntax and underlying concepts. Here are just a few moments I picked :
- Java was conceived in the nineties, officially released in 1996-97 (meaning with versions 1.0 and 1.1)
- The first JavaOne conference had around 1000 visitors, the Java Community Process (JCP) was set up mainly as a way to deal with new specifications with IP issues
- Odersky (who was to become the man behind Scala) and Walder in their Pizza into Java paper pointed out that Java was missing generics, lambdas and pattern matching… in 1997!
- In 2004, Richard Stallman wrote The Java Trap, three years before OpenJDK and many years before Oracle final decision to completely open source Java
- Successive Java releases alternated some performance optimizations (for instance 1.3 and 6) and language evolution (for instance collections API with 1.2, new IO with 1.4, generics and annotations in 5, dynamic languages in 7, lambdas and streams in 8, modules in 9)
- It was funny to observe how the sample code was becoming more and more expressive and light, ending with one single functional programming expression
- Major events also occurred as we all know: JIT compiler became freely available, OpenJDK was open sourced, Oracle bought Sun and Java, IBM OpenJ9 was donated to the Eclipse Foundation
What a journey in 20 years! A lot of things evolved in its syntax, concepts and governance. But Java is still here and widely spread.
Jean-Michel Doudoux is another person very active in the French Java community with his huge tutorial Développons en Java) composed of 117 chapters and more than 3000 pages! His talk was a very good complement of Rémi’s, in French this time with quite some (French) humor. Starting with how to run Eiffel on the JVM ;) And the title “Back to the Future with JMX”: luckily the talk wasn’t about ten years of Java Management Extensions… JMX just being Jean-Michel’s trigram.
Anyway this is a good transition to Venkat’s talks.
Programming paradigms in Java
Probably the best way to discover Venkat’s presenting skills if you don’t know him yet, is to watch one of his recorded talks. This is because Venkat is a serial live coder, meaning he just uses an IDE for his presentation, period. No slides at all, just text and code. For instance check this video to have an idea of his very own way of doing it.
Paris was his last stop in a worldwide tour across 50 JUGs. A very nice trip to celebrate his 50th birthday.
During these many years Venkat lived several shifts:
- programming itself: when he moved from paper where he used to write down his algorithms and programs to actual computers (when he was finally able to get access to them)
- object oriented programming
- distributed object programming (with CORBA)
- event-driven programming (via the asynchronous Node.js)
- functional programming
- reactive programming
Venkat gave us two consecutive talks regarding functional and reactive programming in Java.
Functional programming is not new, the paradigm is even quite old: sixties for computing and thirties for the mathematics of Lambda calculus. It is becoming mainstream only now in the Java world but as Venkat says:
It takes a generation to shift paradigms
In a nutshell, the original imperative paradigm of Java is to state what to do and how to do it with a syntax to structure and control operations (if/then/else, for/while loops, etc.). This is to be opposed to a declarative paradigm focused on what and not how (no statement on the order in which operations execute).
Functional programming for Venkat is the combination of declarative style and higher-order functions, meaning functions applied on functions. This allows functional composition on streams (code is expressive) with lazy evaluation (code is efficient).
One way to illustrate the paradigm shift is to compare:
- a List: imperative, like a bucket, basically a collection of data
- a Stream: functional, like a pipe where data flows, basically through a collection of functions
This means that functional programming requires immutability of data. This allows lazy evaluation.
For Venkat the reactive paradigm builds on top of the functional one or is an application of it. Reactive programming is actually dataflow computing, away from the CRUD style of programming centered around the database. Database then shouldn’t be exposed, only data should be exported. Venkat nails it down with:
In life you should never share two things: your toothbrush and your database
And of course reactive applications have to be elastic, message-driven, responsive and resilient.
Venkat finished with a detailed comparison of Java 8 and reactive streams (like in Spring Reactor, Vert.X or RxJava) to illustrate the paradigm shift:
- they both deal with functional pipelines and lazy evaluation
- reactive streams won’t blow on error: errors is data as well and are streamed in a specific channel
- they can have multiple subscribers and the different sessions can be shared or not between subscribers
- reactive streams offer several strategies to subscribers to cope with a backlog of unconsumed items with the concept of backpressure (buffering items, dropping items, consuming the latest item, etc.)
This all may look way too theoretical and abstract (and well… it kind of is for me) but Venkat has this gift of making you able to grasp it through live coding examples. So if you felt a little bit lost in paradigm shift during the last minutes of reading, don’t worry. Just watch Venkat’s video and it will be far more understandable, for instance:
My conclusion after such captivating talks is: Java is definitely an evolving language, should I dare to say it is now entering its adult phase? No Raphaël, enough troll feeding for today!
A big thank you to the Paris JUG for this event and for everything they achieved in 10 years. I can’t imagine where we will be in 10 years from now… They might have to make us cross the river and book the Louvre museum for this event!!!
If you live near Paris or you are just passing by and want to visit one of its (Java) monuments, go to Paris JUG events! You’ll meet there a thriving community lead by some amazing guys (most of them are also part of the Devoxx France team and Les Cast Coders Podcast).