Java Forum Nord 2018 Retrospective

This article is dedicated to the non-commercial Java conference that I visited on September 24, 2018, in Hannover, Germany, known as Java Forum Nord. The spoken language is German but the presentations consist of diagrams and code examples so they can be understood by the non-German-speaking readers. I want to list here the lecture which I have visited with links to the presentations and also lists with headwords.

Networking Instead of Waste: Let's Talk — Stefanie Reinicke, Dr. Jan-Christian Dammann

This presentation was about making development teams stronger through three topics:

1. Experience sharing via:
   
• Writing documentation
  
• Writing topics in blog/online forum
• Organizing a technical meeting
2. How can we agree on the proper solution?
• By leading controversial discussions
• By organizing Q&A sessions
3. How do we promote the sharing of experiences?
• By organizing a chat on a daily basis
  

Functional Programming Is Also Possible With Java! — Falk Sippach

In this presentation, an example of functional programming was described based on the Luhn algorithm that is used for the validation of credit card numbers.

The implemented Luhn algorithm in the functional programming style is intuitive to read and understand. Not only the functional programming style but also the code style from the presenter made it much easier to read because every function was declared as a separate variable.

Some frameworks used for the example include:

• Vavr
• Immutables
• Project Lombok

Other frameworks mentioned include:

• Functional Java
• RxJava
• Vertx
• JOOQ
• JDeferred

Self-Management 42.0: How Enthusiastic Software Craftsmen Can Optimize Their Lives and Achieve More — Steven Schwenke

This presentation consisted of two parts.

In the first part, self- management was described as something that is developed by the presenter and is very similar to the agile software development method SCRUM. Weekly planning was described in an organizer block, which the presenter wears in his pocket and uses for his everyday activities.

What I found to be missing from the self-management 42.0 method of planning is spontaneity and freedom, because every task was well-thought out and described in the organizer's book, which requires more effort and time.

In the second part of the presentation, the presenter was introducing books that gave useful ideas to the presenter for developing the end state of the self- management method.

Microservices and Macro-Architecture: Three Key Design Issues in Vertical Application Architectures — Stefan Zörner

This presentation discussed the microservices and macro-architecture. Before a system based on microservices is built, the following questions need to be addressed:

• Interaction with:
• UI
• Communication and integration
• I18N
• Ergonomics
• Validation
• Under the hood:
• Persistency
• Security
• Transaction handling
• Session and state handling
• Event and error handling
• Multithreading
• Caching
• Development
• Agile software methods
• Versioning systems
• Continues Delivery and Integration
• Production Environment
• Distribution
• Deployment
• High Availability
• Virtualization
• Scalability

The three design issues in vertical application architectures are:

• The UI Question? Two approaches were presented:
• One client that communicates with all microservices
• Every microservice has its own UI
• Communication — what should it look like?
• Synchron vs. Asynchron
• Direct vs. Indirect
• We looked at an example, which consisted of a combination of the previous measurements — Direct and Synchron
• Security
• Authentification — central
• Authorization — decentral

Further information mentioned in the presentation:

• SCS — Self-contained Systems
• IPA — Independent Systems Architecture

Better and Easier Code With the Java Annotation Processor — Gunnar Hilling

This presentation was about the annotation processing API. It is an example annotation that creates a static metamodel of the interface. In the next part, a validator for the correct usage of the defined annotation was presented. The testing of the new implementation was also presented.

Terminology:

• JavaPoet is a library for creating Java code via its API.

I have to admit that this was a presentation with a theme — which was new to me. Honestly, I could not come to any conclusions on the main motivation or benefit of using this kind of programming. Perhaps, I was just too focused on the topic title, which claimed "better and easier code."

Proper Integration Tests With Test Containers — Philipp Krenn

This presentation began with examples where the unit test passed but the functionality of the system unit was still not correct. Another problem mentioned here is when the test is based on mocks, which are artificially created overcorrect, extract for the very test case.

In the following presentation, some frameworks and libraries were mentioned with demonstrations (the links are in the presentation):

• Embedded Elasticsearch (a tool that eases up the creation of integration tests with Elasticsearch)
• Flapdoodle.embed.process (will provide a platform-neutral way for running processes in unit tests)
• Docker-maven-plugin
• Moby Ryuk - Schedule Moby/Docker containers cleanup after a specific delay
• Dockerized Elasticsearch container for testing under Test containers

Pair and Mob Programming: the Essential Ingredients for Successful, Modern Agility — Thomas Much

This presentation was about pair-programing and mob-programming techniques. It explains why pair-programming is good for your team and how to do it correctly by describing the methods and benefits of it. Also, mob-programming was introduced where all team members, like the PO, QA Dev's, and Dev Op's, are involved in it.

Closing Keynote: Long-Lasting Software Architectures — Without Debt That Will Last for Decades — Dr. Carola Lilienthal

• https://www.youtube.com/watch?v=vp4YQJvafO8
• https://www.youtube.com/watch?v=Nfzuy4L9_UM
• https://www.youtube.com/watch?v=M6sprMtD6nA

This presentation is about technical debt. I was familiar with this presentation because I have listened to it two years ago at a conference, JavaLand 2016.

• Technical debt on a software project level is the recognition of bad architecture through analyzing the software via tools.
• Refactoring after this step of development results in better software.
• For a good architecture, the software needs to have good:
• Modularity
• Hierarchy
• Pattern consistency — technical/ functional layer
• Examples of detection of bad architecture
• Tools for detection of wrong architecture (wrong structure, hierarchy, dependency)

Summary

Java Nord is a one-day, non-commerce conference with four tracks that are organized from several Java User Groups (JUG's) located north of Germany, and it is free for the JUG members.

For some of them, I am able to guess the content from the title and the description, but for others, it wasn't so obvious. Either way, it is always a good experience to learn something new.

Writing this article, I noticed that almost all of the linked presentation were in German, which was not the case in previous conferences. However, the code and charts can be understood by all language-speaking developers.