JAX London

The JVM contingent of Hive took a trip down to London at the beginning of October to attend JAX London which bills itself as ‘The Conference For Java & Software Innovation’. I’d attended the same conference three years ago and enjoyed it. However, I felt hesitant recommending it to the others, all of whom are highly experienced & opinionated developers. Back then the conference followed 2 strands and was entitled JAX DevOps but as the roles of developers and “DevOpsers” have become increasingly intertwined they’ve evidently decided to ditch the DevOps part.

Anyway, I needn’t have worried. With the exception of several motivational speakers during the keynote speeches, which weren’t quite my bag, there was enough new tech & takeaways in there to arouse our curiosity & keep us googling in the desire to find cooler and better ways to achieve our goals.

Three years ago, the conference content was heavily orientated around the then relatively new concepts surrounding microservices, monitoring, security, containerisation & continuous delivery. The same appeared to be true of this year’s. So I was interested, three years on, to see how things had progressed, how tools had developed, what the issues encountered or pain-points had been & how, with the benefit of hindsight, people’s perceptions and approaches had changed.

All of us bar James C are experienced Java devs so consequently first up for the majority was a talk entitled All the way to 11: Delivering new features in the JDK given by Simon Ritter of Azul Systems Inc. Simon covered how the Java platform is evolving with the introduction of features like the Java Platform Module System in JDK 9, local variable type inference in JDK 10 and dynamic class file constants in JDK 11. Additionally, he spoke of what JDK 12, 13 and 14 might include. However, the subject which evoked the most discussion was Oracle’s handling of the new Java licensing agreements. There was a similar talk which I didn’t attend later the same day entitled Java releases and support: Untangling the confusion which covered the question in more depth.

In brief, we’ve all got used to using the same version of Java in our dev, test & prod environments for free, but as of Java 11 Oracle will no longer be providing free long term support. They’ll be providing two builds: an Oracle commercial JDK build and an Oracle OpenJDK build. These builds are functionally the same but, if you’re using the commercial JDK, you’ll get updates and support. If you’re using the OpenJDK build, they won’t be providing updates to past versions.

There are other vendors providing JDKs who have different support models (free and paid), and different attitudes towards providing updates for different versions of Java. Therefore, Java users have some decisions to make which appeared to be:

  • Follow each update every half year in your production system.
  • Decide to base your production system on one of the supported versions offered by Oracle, Azul, AdoptOpenJDK or IBM to name a few.

As a group we seemed to be leaning towards the approach taken by the AdoptOpenJDK community.

Next up was Andrew Rouse, a software engineer at IBM, who ran through How to build a 12-factor microservice in an hour using the the Eclipse MicroProfile programming model, which is apparently ‘An initiative that aims to optimize Enterprise Java for the Microservices architecture’. There wasn’t too much here that I’d not covered before although the MicroProfile model might be worth a deeper dive.

I attended It’s all about Morphisms by Uberto Barbini from Gama-soft, in part, to brush up my functional programming & with the added motivation that I may be better equipped to understand what the heck my son is doing at Liverpool Uni in his final year project (he’s using Haskell & Tidal Cycles to produce live coding musical patterns using chaos theory). Uberto described his talk as a gentle introduction to Category Theory for programmers used to OOP but interested in functional programming. No Haskell knowledge required. I’m not so sure the latter was necessarily true but I more or less followed Uberto for the first half of his talk and then things became a little blurry. However, I have added monoids, monads & functors to my growing list of stuff that I should know more about. One thing that I particularly want to explore along with my recent Kotlin endeavours & which he touched upon during the talk was Arrow-kt which is a functional companion library to Kotlin’s standard library.

Kotlin again was covered in Changing code with Kotlin. This was more or less a public pair programming exercise running through the Kotlin basics, most of which I already knew but which was a welcome refresher nevertheless & was probably useful to the uninitiated.

Last speaker of the first day was Jessica Deen of Microsoft who gave a great presentation on the subject of Devops with Kubernetes and Helm. Jessica was also sporting some pretty cool binary tats which were an original take on the enduring Love & Hate favourite. Her talk was a slick demo of the pipelines now offered by Azure which are more or less akin to the Gitlabs auto devops pipelines I’d been exploring a few months ago. One thing I’d not come across which Jessica demoed was Draft which appeared to be a super easy way to build applications that run on Kubernetes. Definitely worth a look.

Cool tats

I kicked off the following day with a talk by Bernd Rücker of Camunda entitled Three common pitfalls in microservices integration and how to avoid them. I’d explored much of the material previously but, to summarise, the talk primarily covered:

  • Communication is complex. Failures are normal so you need sophisticated failure handling strategies.
  • Asynchronicity requires you to handle timeouts cleanly.
  • With distributed transactions you need to solve the requirement to retain consistency in case of failures.

I’d seen one half of the duo from Google, Robert Kubis & Ray Tsang, the last time I’d attended JAX. This time together they entertained with an initially failed demo which almost had me fooled before, of course, they rather expertly turned things around with their Troubleshooting & Debugging Microservices in Kubernetes demo. I came away impressed by the manner in which you’re now able to debug & even change code on the fly in a live system via the Google Cloud / Kubernetes interfaces. You can now install the Stackdriver debugger in IntelliJ and debug live code or add log messages to the live environment. If you want to know more, here’s a link to a previous demo Ray gave albeit with a different straight man.

Post lunch, I watched a second talk given by Ray who introduced us to Istio, an open source service mesh framework created by Google, IBM, and Lyft. At a high level, Istio helps reduce the complexity of handling the deployment and monitoring of large microservice based systems. Quoting from the Istio bumph, it allows for:

  • Automatic load balancing for HTTP, gRPC, WebSocket, and TCP traffic.
  • Fine-grained control of traffic behaviour with rich routing rules, retries, failovers, and fault injection.
  • A pluggable policy layer and configuration API supporting access controls, rate limits and quotas.
  • Automatic metrics, logs, and traces for all traffic within a cluster, including cluster ingress and egress.
  • Secure service-to-service communication in a cluster with strong identity-based authentication and authorisation.

Ray’s demo was very impressive, as were the tools provided by Istio, but it’s definitely something that I’ll need to dive a bit deeper into to fully appreciate.

The final speaker I saw, Ted Neward, began by flying through the chequered history of Javascript, which, given my current sabbatical from JVM languages, and the fact that I’m now all about the React & Gatsby, seemed appropriate. In his talk, Busy developer’s guide to Not Javascript, Ted did asked for a quick hand-show to determine how many devs thought there was something wrong when you look at the never-ending list of ways that people have used to avoid writing Javascript. He also asked how many in the room were tired of all the quirky behavior around Javascript and wondered if there was something else that could run in the browser, do all the things that we want Javascript to do, but without having to put up with Javascript’s nature. Whether WebAssembly will replace Javascript remains to be seen but according to FAQs:

WebAssembly is designed to be a complement to, not replacement of, JavaScript. While WebAssembly will, over time, allow many languages to be compiled to the Web, JavaScript has an incredible amount of momentum and will remain the single, privileged dynamic language of the Web.

In short, WebAssembly is a binary format for web applications which allows web applications to behave more like desktop applications. Developers write in Kotlin, C++ etc. and then, similar to how a desktop application is written, code is then compiled into WebAssembly binary. Apparently, the main advantage is performance (20x faster than Javascript to parse “apparently”, due in part to using statically typed languages), and the main downside is that development is a bit harder. I’m just in the process of trying it out so I’ll let you know how I go.

So all in all a good trip. Not everything was inspiring but the majority of it was and I think it probably helped that I was hungry for new stuff to look at having spent the previous 6 months working on a client site on an old PHP stack which perhaps wasn’t a natural fit for me. There were heaps more speakers that I sadly didn’t have time to hear but some of my fellow Hivers did and who may share their experiences in future posts.

Traditional programmers pizza break