Modern JVM Development Bash!

Futurology in our industry is wildly inaccurate, if not completely wrong. One prediction from the 2010’s that did come true, was that we would move into an age of polyglot programming. Today, in Belfast alone, we have vibrant Go, Rust, Swift and Erlang communities - in addition to all the usual suspects.

Yet, despite this proliferation, the JVM continues to dominate, for three key reasons. First the Java language has rejuvenated itself, by adding features whilst preserving compatibility. Second alternative JVM languages like Kotlin, Scala and Clojure continue to grow in power and popularity. Third, the JVM itself is adapting to better meet contemporary needs, for example through GraalVM and Project Loom.

In this BASH, we will have three excellent talks that show, from different perspectives, why the Java Platform remains the one to beat. Please come join us!

------- Talks ------

Talk 1: Java After Eleven (Nicolai Parlog)

In this live-coded talk Nicolai will update a Java 11 code base to Java 16.

Many projects that updated past Java 8, chose to stick to version 11. The six month release cadence created the illusion of not much happening after that. However, nothing could be further from the truth. With new language features like switch expressions, text blocks, records, and sealed classes, Java is moving faster than ever.

In this talk we'll take a simple Java 11 code base, update it to 16 and refactor it to use the new language features and APIs. You'll be surprised how much the code changes!

Talk 2: Shipping It All The Way - To Production! (Amy Crockett)

Keeping a network of microservices correctly configured, whilst moving them through release environments, can be complex. When it comes to getting code out to production shifting endpoints, external services and differing test / production setups all make for a precarious scenario.

This talk shares the latest approach for keeping your microservices in line. We will show how to use Jenkins, Helm, Docker and Kubernetes to build, maintain and deploy your release environments peacefully.

Talk 3: Smash Your Adapter Monolith With The Connect Pattern (David Denton)

Server-side code is regularly broken down into manageable chunks, based around endpoints. As a result it tends to be nicely factored. But over several projects we noticed that the same was not true of adapters that talk to 3rd party systems. These pieces of code tended to grow uncontrolled, and were not given the same level of attention.

In this talk, I'll be covering a pattern that we discovered to help break down your Adapter Monolith into modular, easily digestible and (most importantly) testable pieces.

This talk is based in Kotlin and takes advantage of language features such as Data Classes, Companion Objects, Operator Overloading and Extension Functions. However the pattern concepts themselves are applicable to any technology choice or programming model.

------- Bios ------

Nicolai (aka nipafx) is a Java enthusiast focused on language features and core APIs with a passion for learning and sharing. He does that in blog posts, articles, newsletters, and books; in tweets, repos, videos, and streams; at conferences and in-house trainings - more on all of that on https://nipafx.dev. That aside, he's best known for his haircut.

Amy has been working with code for just over 10 years. Most of that time has been spent in Java backend development, with the occasional foray into Kotlin or one of the Cs.

David is a London-based Engineering Lead, Trainer and Open Source fanatic. He’s been tippytappying for about two decades, building software and teams delivering projects working in Finance, Publishing, Internet Provision and most recently the COVID-prevention business. He is the co-creator of http4k, a functional toolkit for building HTTP applications in Kotlin, and spends far too much time thinking about Lego.