So it’s been 3 years since Devoxx organized a physical conference and it all started with an amazing breakfast and a cup of coffee to give us energy for the amazing talks to come.

Stephan Janssen was thrilled in his keynote on Wednesday to welcome us back.

For some of us working at JArchitects it was indeed a warm welcomed return, but for some of us it might be the start of a yearly pilgrimage to Antwerp.

At least, if we can hold off on tickets next time. This year, the first batch of 1600 tickets were sold within 5 minutes while the remaining second badge was out in a matter of seconds.

Since last edition, the AI field has undergone a tremendous series of new developments.

A concrete example of this: the captivating introduction movie made for Devoxx is mostly `text to movie` generated

Alan Thompson, as keynote speaker, reminded us how AI evolved from the days of Alan Turing up to the latest and ubiquitous AI generated Art engines, AI co-authored books, AI robots and many other examples that are becoming part of our everyday lives.

One of such recent developments is the AI-augmented coding tools that might help us, developers, to write better code by taking out the boring, tedious and error prone part of code writing. Andy Piper of the Diffblue team had a talk explaining how they can help generate Unit tests through AI which sparked quite some interest among the participants as all seats were taken.

As for Javas developments, Venkat as keynote speaker, proved why Java is in fact Agile by releasing in 6 months cycles carefully adding features that are productive for developers while keeping it backward compatible and future proof.

He highlighted some of such features like heredoc (multiline), pattern matching, records and virtual threads, now being mature enough to leave their incubation rooms of Project Amber and Loom.

Jose Paumard (Oracle) dived deeper into ‘Clean Code with Records, Sealed Classes and Pattern Matching’ while reminding us not to postpone the upgrade to at least Java 17 in order to benefit from all these latest and greatest new features.

We also got a glimpse of features that are yet to come in future releases. In another talk, Mario Fusco made an interesting Java version of the Game of Life in which he used and benchmarked the novel ‘virtual threads’ concept and reminded us that domain knowledge still matters a lot in order to achieve great performing results.

Whenever we were not seated in the cozy theater seats or having lunch just around the theater doors, we were hanging out downstairs where there were plenty of activities to do during the breaks.

Like trying our skills in darting at the Continuum boot or playing coin pushers and so much more! It is here where we can mingle with our peers, perhaps find an old colleague and have a talk with the other companies at their boot.

It was also fun to see we had some “makers” speaking at Devoxx, Joel Lord (MongoDB) is a Canadian hobby beer brewer and dared to explain in Belgium how to brew a beer. Job well done, unfortunately it didn’t involve beer tasting by the audience but his IOT solution taking measurements during the brewing process were very cleverly applied and put MongoDB cloud solution to good use. And anyhow, to quench our beer thirst, no worries: a company of tech savvy people was handing out locally crafted beers throughout the event at the sponsor-floor downstairs. Guillaume Laforge (Google) wanted to keep an eye on his 3d prints during printing and didn’t feel like buying an off-the-shelf solution, so he repurposed his old smartphone and built a monitoring solution with WebRTC at its core with a pitch of Google Cloud Run services.

Did you know the average age of a developer is 28 years? And therefore a developer well beyond that age, can feel old. But Tobias Modig (Citerus) had a cheering take on this: they might be slow, but slow is good! Building it right instead of fast, having sustainable development like the 8th principle of the Agile Manifesto prescribes are key elements to adhere to. But also time to practice and read on books much like Tom Cools (Info Support) advised us in the ‘Learning Through Tinkering’ talk: as ‘Technical implementations decay faster than the concepts they are based on’ it is a good practice to keep on tinkering on those little projects to keep your technical knowledge ‘toolbox’ up to date.

Uberto Barbini, in his talk ‘From objects to functions,’ took Kotlin and introduced known functional paradigms such as Functors and Monads, applying them in a practical way to a web application. Through practical examples and a little code, Uberto shows how an API can reach a level to which anyone can read it.

By further ingraining these ideas into modern architectural solutions such as a hexagonal architecture, functional programming can be used as a way that’s not too exotic to existing codebases, solving real life problems in an efficient way.

According to Uberto, when done correctly, the resulting codebase will show the defining features we all love and work towards, such as code that’s easy to test, TDD, consistent, DRY and meaningful logging.

Often developers get tasked with introducing new functionality, in legacy codebases. One of the requests is often to go cloudnative in order to have a competitive advantage over competing brands. When bringing an old existing monolithic application to the cloud, a lot of issues usually arise concerning cost and time. Not only that, sometimes the legacy application can’t be touched, or the new features are dependent on the legacy systems’ data.

When dealing with such problems, software engineers often will step into the trap of anti-patterns. These anti-patterns do not only introduce extra complexity down the road, but potentially introduce corruption in the existing data or transformative data. Karina Varela (Red Hat) introduces an architectural approach to solve this problem.
Karina builds a new application in the cloud with modern ideology, following all the things developers enjoy about microservices. To resolve the dependency on the legacy system or data, open source software is used, namely; Debezium and a messaging bus like Kafka to the existing architecture. Debezium can read actions performed on a database. Following, Debezium publishes the events to the message bus. This allows the new microservice application to update its own data accordingly in an event driven way.

Josh Long (Vmware) teamed up with James Ward (Google) giving an energizing live coding demo in ‘Spring + Kotlin = Modern + Reactive + Productive’. With Micrometer, Spring is wrapping most of OpenTelemetry and in ‘The state of OpenTelemetry for Java Developers’ Philip Krenn (Elastic) explained how language and framework specific agents manage to get tracing and metrics data and how exactly OpenTelemetry helps in providing a vendor neutral unification of instrumentation.  Brian Clozel (Vmware) and Stéphane Nicoll (Vmware) introduced Spring Framework 6.0 which we’ll briefly cover here:

A major feature in the new version is observability. Observability includes logging, metrics, traces, data collection and visualization tools.

In the past, the Spring code and some libraries were instrumented for observability using java agents at the bytecode level, using public extension points and direct instrumentation in the library.

But over the years they’ve found quite a lot of problems with this approach. So with this new major version they will be using Micrometer 1.10. As of now, web servers and web clients are instrumented without having to use Spring Cloud Sleuth to be able to have metrics like error rates for specific APIs. You can also have correlated logs with the actual correlation ID spanning different services. On top of that, you have the actual traces visualizing a client sending to a server on which in turn is sending to something else and so on.

AOT and GraalVM Native
In 2019, Spring started working on an incubation project called Spring Native providing support for compiling Spring applications to native executables using GraalVM. Over the years, GraalVM evolved and improved a lot and thanks to that, native support is moving to general availability within Spring Framework 6 and Spring Boot 3. This is why they’re about to officially retire the Spring Native projects.

Java interface Clients
Spring framework has a class called RestTemplate and they added later on a WebClient as a non-blocking alternative to RestTemplate. Using these 2 classes you have some utilities to perform HTTP requests. However, it still requires quite a bit of boilerplate. In the screenshot below you will see an example of a very happy flow without error handling.

With Spring framework 6 you can now use HTTP interfaces. You simply create an interface and add a contract declared with the @GetExchange annotation to perform a GET request.

After doing so, we need to create an actual HTTP client to use our contracts defined in the interface:

As you can see, we highlighted in this blog only a few of the many talks that were held at Devoxx, luckily all of them are recorded and published on Youtube:

So we definitely suggest watching some of those to get a bit of the Devoxx vibe and knowledge. Hopefully we can meet each other next year at the 20th edition of Devoxx 2023!