Javaland 2019

A conference of extra class

This Article shows my personal impressions as lecturer and visitor. The Javaland conference 2019 took place from 19.03. to 21.03. at Phantasialand in Brühl, Germany, during fantastic spring weather. The organizers spared no expense. There was excellent food, from sausages and burgers up to the Asian buffet in high quality restaurant quality. Lunch and dinner was free, including beverages. There were coffee shops with ice cream and muffins. You had incredible choices of fruits. I have not experienced anything like this at any conference. Even in the US: @Oracle: Dr. Pepper and snacks in plastic wraps are not the kind of stuff developers need ;-).
In the two days, I have remembered a few lectures. The level was unbelievably good. Here are the best lectures I have attended:

Coding That Sparks Joy with Quarkus

https://programm.javaland.eu/2019/#/scheduledEvent/580174

The talk showed how Java technology can be used, to build applications that show similar resource and runtime behavior compared to applications written in Go. Quarkus is a combination of modified libraries that run as binaries, compiled with the Graal VM. Quarkus supports a subset of the CDI specification and generates static dependency injection code (DI) at compile time. This has massive benefits in terms of start time and application footprint.
The statically generated application contains in the end only the required classes, which are still kept in a cache. The GraalVM makes native programs that start in a few milliseconds and require very little hard disk space.
A highlight was the Quarkus Developer Mode, started with Maven, which installs and starts the application immediately whenever saving source files. Since this happens in a very short time, you have the impression of a patched application as tools like JRebel do. Unlike Debuggers or JRebel, the technique Quarkus uses has no problem with static references or corruption.
Thus, Java comes now as 1st Class Citizen in the cloud. This allows you to build high-performance and resource-efficient applications for the cloud similar to the once you would write by using a static compiled language like Go.

https://developers.redhat.com/blog/2019/03/07/quarkus-next-generation-kubernetes-native-java-framework/

Hexagonal Architecture with Microservices

https://programm.javaland.eu/2019/#/scheduledEvent/569593

The talk shows the hexagonal architecture pattern. In essence, the idea is very old (1990): “Build an application core that is technology independent and contains all the business logic”. That sounds simple, but requires discipline and decoupling. For example, the application core must be separated from the database via an interface (aka Repository). The interface is part of the application core and should therefore have no dependencies on classes or interfaces that are technology specific (For example http, db). The interfaces are connected via Dependency Injection to the application core. In hexagonal architecture these interfaces are called “ports”. The implementation for a concrete database is called “adapter”. There are “driver” and “driven” adapters. A driver adapter is directly called from outside (for example a HTTP Rest controller) The hexagonal architecture is therefore also referred to as ports & adapters architecture. Complete independence of the application core does not always work. Annotations such as @Transactional may already refer to a specific technology for database access. The decisive factor here is whether it is possible to exchange the technology (for example Mock-DB instead of a real DB) without changing the application core.

It was a good talk with some interesting thoughts. You can find the presentation slides here:

Untangling the Mysteries of Qubits

https://programm.javaland.eu/2019/#/scheduledEvent/570029

An ingenious talk about the functionality of quantum computers. The talk has explained the topic very clearly and understandably. The operations on qubits were explained using simple Java matrix operations with source code. Speaker was Roy van Rijn. Roy is director and co-owner of OpenValue Rotterdam and software developer at JPoint

The Qubit itself was visualized by a skippyball, whose orientation was easily recognizable by a face at one side and a handhold at the top.
Quantum effects were explained by polarization filters and the double-slit experiment. The reversible application of applying gates to qubits was visualized by rotating the skippyball and the beloging matrix operations..
The two basic algorithms (linear data search) and prime factorization (Shore Algorithm) were well explained.

Thanks to Roy! You did a great job.

From modular Architectures to Microservices

https://programm.javaland.eu/2019/#/scheduledEvent/569704

A highlight of the conference. Dr. Carola Lilienthal explained how to cut a system into microservices and why redundancy is not a problem in many cases.

Putting Microservices on a Diet with Istio

https://programm.javaland.eu/2019/#/scheduledEvent/569840
A cool talk about Istio. Istio is a technology that allows cross-cutting Concerns (Logging, Security, Load Balancing) to attach to services from the outside without code changes. Mario Leander Reimer shows how Canary Deployments works with Kubernetes and Istio.

Microservices compared with Java and Go

https://programm.javaland.eu/2019/#/scheduledEvent/569728

This was my own talk about developing Microservices with Golang. On the basis of simple code examples, Golang was introduced. Prejudices such as “Go is not a OO language” were cleaned up. The talk introduced Microservices with the Go standard library, gRPC and a Microservice toolkit called go-kit.

My slides can be found here:
https://www.javaland.eu/formes/pubfiles/11121405/2019-nn-johannes_weigend-microservices_mit_java_und_go_im_vergleich-praesentation.pdf