20th Devoxx Belgium Conference 2023

Integration tests verify your application is working as expected.

Test containers are a powerful wrapper around docker. You can create the integration environment and the continuous delivery pipeline in Java.

If you prefer to write and debug your integration setup in Java, test containers are useful. The demonstration highlighted you have anyway to learn the subtleties of Docker. You can write your setup code in Java, but it requires quite knowledge about the underlying tooling.

A cool hint was toxiproxy to simulate network delays and errors.

Alternative approaches are docker compose or plugins such as jib.

I am still not convinced the gains using test containers are worth learning a new library. The assumption is that you are already proficient with Docker and Docker Compose. Test containers are certainly useful when you have a complex ecosystem with databases, servers, and a lot of microservices.

I often have a modular monolithic application. I use Eclipse Store and embedded HyperSQL for persistence. I use Flyway to populate the database. My docker compose file is simple and straightforward.

Why should I add the complexity of test containers?

The introduction was well-done. Honestly, if you read the JSR and articles during the early-adopter phase, you did not get new information during the presentation.

The presentation is for Java developers lagging behind the latest Java LTS release. Modern developers evaluate a new Java version before it is officially released.

Data-oriented programming separates data and code. This approach is against core concepts of object-oriented programming.

The speakers talked about the disadvantages of recompiling code when changing an interface. But honestly what are the costs of compiling in a modern DevOps environment?

The advantage of declaring a static method instead of a default method in the interface is not visible to me.

Use sealed class hierarchies, pattern matching in switch expressions to delegate complex business logic inside business classes.

Consider using records to write less code and move in the direction of immutable instances.

Deconstruction patterns and unnamed variables make the algorithms more legible.

Avoid Anemic Domain Model. I acknowledge there is a tension between behavior which should be part of a class and complex business logic which should be defined separately from the core domain abstractions.

The above constraint clearly defines the tension in designing the abstractions for a bounded domain. Both variants are mutually exclusive in modern programming languages.

An experienced architect with domain knowledge should hint which functionalities belong to a class and which ones are better located in business logic abstractions.

Future constructs were also presented.

Named patterns are a discussion theme in the community. They support the deconstruction of regular classes.

Value classes as potential first preview of the Valhalla project. Value instances have no identity anc can be stored on the stack. Interestingly, the optimization is only done at runtime.

They stated discussions is under to integrate null annotation in the language as discussed in JSpecify ^[3].

Simon Brown provided a nice introduction to C4 Model: Context, Container, Component, and Code.

The explanations of Structurizr DSL and examples were interesting.

The examples showed that often you start programming diagram items and contents.

The major drawback is that Structurizr wants to be the ruler of your documentation. You cannot create a static website with the diagrams and the links between them. The tool plantUML supports such features through the SVG output.
Instead Structurizr requires that your Asciidoc or arc42 documents are integrated into it.

The idea to add a semantic abstraction layer to diagramming tools is brilliant. I think the current solution should be improved to simplify diagram handling.

Entertaining and professional presentation of Java quirks. The examples show Java software archeology. Old coding and naming decisions coming back to bite you.

New features have sometimes strange impacts on existing code, often due to bad naming or interface segregation troubles.

Funny examples of how to write unit tests for crap code. The end of the talk presented good design approaches and the need to refactor. The speaker, Victor Rentea, outed himself as a clean-code advocate.

Rely on the language and not on tests to detect errors is profound advice.

The C++ bashing was surprising.

The attendees hinted that a lot of legacy code exists. Developers are under the yoke of maintaining and extending geriatric solutions.

I rather advocate performing refactoring to remove technical debt before trying to add functionality. I fully agree that there are rare exceptions due to important business deadlines. Here you could use the tricks with mocks, partial mocks, breaking information hiding to test legacy code.

Be honest. I would never work on a crap software code application. Either the company is resolute with professionalism and supports refactoring. Or I would look out for a serious development environment.

Event-first design is another approach to looking at your domain.

Ensures there are event handlers for all emitted events before they are effectively persisted. The event sourcing runtime should ensure the approach.

Projections are used to process events and create a query optimized views on the model. The concept is similar to a materialized view in a relational database. Events are sent at least once to projection event handlers ^[4]. Scalability is realized through slicing of the event store. The slicing property is the stable identifier of the entity referenced in the event. Design your system accordingly.

Choreography sagas are completely based on events and projections. Once triggered, it moves like a wave until completion. Therefore, no error should block the flow and they are hard to debug.

You can use complex sagas with orchestration tools such as Temporal or Camunda. A trend is to offer PaaS solutions built around a kubernetes cluster.

The presentation was fun, instructive, and well-done. The details were inspiring and of high quality.

The speaker showed multiple areas where the JVM was locally massively improved through clever refactoring. Worth every second and a nice way to complete the day.

The themes are Java and AI. Artificial intelligence is a hot topic with few concrete scenarios. The three most cited areas are personal assistant, coding assistant, and image generator.

A good coding copilot would be a great use case. Jetbrains and other companies' solutions are still work in progress and often not released to the public.

And two talks about physics and quantum computing.

Brian Goetz presented the new features of Java 21. An alluring idea was presented. Library owners should follow a similar release strategy as Java.

Beginner introduction of byte encoding for the payload.

The speaker advocates the use of cheap raspberry boards to experiment.

Smaller data packages reduce energy consumption, network traffic, and surprisingly also latency.

ProtoBuf is a good compromise to encode payloads. Hand-coded structures are still factors more compact but require code to encode and decode the payload.

The speaker shows a demonstration of time series in postgreSQL. Nice to learn the database supports the feature, and I missed concrete examples why I should use it.

Brian Goetz explained the various mechanisms to speed startup time and increase performance. In the end, Java programs should be more cloud-friendly.

Use AppCDS to improve the startup performance of your application. It should be a standard step in your deployment before packaging your application into a Docker image.

Ideally, some improvements shall be delivered with JDK 22.

Speakers presented the huge gains moving from JDK 8 to JDK 17.

They had a few regression cases when doing such a huge jump in versions. The troubles were methods or classes no more accessible in the newer version. Just read the log files; the encountered restriction always generates a log describing the problem.

Beware that more threads can be active in garbage collection in newer versions.

They provided an interesting argumentation why they will wait with the update to Java 21. The known bugs are too critical to update such a huge installed base.

James Gosling was interesting and getting older. He had a point that multiple libraries implementing the same functions are eating away your memory. A Java application should have one JSON transformer, one serializer, and one HTTP protocol stack.

It was a boring presentation. I know a little about ARM processor architecture. The speaker just presented the different processors available on the market.

No real presentation of how Java is optimized for ARM architecture. He could have presented intrinsics, SIMD support, and other architecture optimizations.

Cloud companies provide ARM-based solutions with tens or hundreds of cores. All Apple computers are running on ARM.

One clear statement was we will run our applications on a platform with a lot of ARM or X86 cores in the future.

Hubert Klein also known as mrhaki is an advocate of Asciidoc. He has a cool blog. I am also a fan of Asciidoc, Asciidoctor, and Hugo.

The presentation was interesting and professional.

The speaker favors integration and production feedbacks on how the application behaves.

He advocates OpenTelemetry because it is an industrial standard.

The Digma plugin is an approach to support developers. Observability metrics are provided during development and testing directly in your Jetbrains IntelliJ IDEA.

Cool plugin providing developer functionality without having to install multiple docker images as with regular DevOps tools.

Funny presentation how to classify Lego bricks using machine learning.

The speaker is not a machine learning ML specialist and had a steep learning curve. All packages are available as open source packages.

The Java ecosystem is smaller and less well-documented. He used Deep Java Library.

One important finding was use real images, do not create them mechanically. The difference is tremendous.

This presentation was the coolest of the whole Devoxx 2023.

The speaker is an active developer of LangChain4J. Her approach solves the troubles described in the previous talk for LLM models.

The code examples show how little code you need to set up a chat agent backed with a LLM model.

You can define your own tools to compute values instead of asking the model to guess them. The next improvement is to ask your model to generate a tool because models can also write source code. This is awesome.

Solid presentation of Jetbrains IntelliJ IDEA debugger features with hands-on examples.

I seldom use the debugger. The tips were good but not really relevant for me.

The speaker presented a solid introduction to gRPC and Armeria.

The frameworks provide necessary services for highly scalable applications based on microservices. Armeria industrializes gRPC services.

The concepts are clean and well-implemented. The decorator pattern is used to add functionality to services. I seldom have non-functional requirements requiring such complex architectures.

A solid presentation about Swing and JavaFX. You can use both libraries in the same application.

The demonstration of an email client was solid. I got the impression that not a lot of innovations are happening in the Swing or JavaFX landscapes ^[5].

The speaker provided a good introduction to Async API and cloudevents.

An entertaining presentation about entrepreneurship.

He had tribulations between Java and .NET projects. I finally got the courage to realize a product idea I had long ago and implement it as an open-source Java. JobRunr was born as a port of .NET Hangfire.

He used redIT to market his product. He enjoys working with the Java community and Java champions. They are very supportive and kind.

The commercial model is JobRunr as open-source application and a paid professional version. The first license is a permanent license to a French company priced 400 EUR.

The breakthrough was a talk in May 2022 at the Spring I/O conference. The ThoughtWorks technology radar mentioned JobRunr and increased the exposure.

He made 90'000 EUR in 2022. The forecast for 2023 is around 260'000 EUR. He hired his first employee.

The whole approach is cute, hands-on, and most importantly, working. He is able to live from an open-source product. This is an impressive and sadly seldom achievement.

Per Minborg provided again a cool high-quality talk about {ref-panama and Foreign Function and Memory API.

An arena models the lifecycle of one or more memory segments. All segments allocated in the arena share the same lifetime. Multiple arena types are provided for different scenarios.

Memory layouts describe the contents of a memory region programmatically.