Java Forum Nord 2017
Java Forum Nord 2017
Take a look at the presentations from this year's Java Forum Nord conference to learn about modularity and microservices and what's new in Java 9.
Join the DZone community and get the full member experience.Join For Free
How do you break a Monolith into Microservices at Scale? This ebook shows strategies and techniques for building scalable and resilient microservices.
This article is dedicated to Java Forum Nord 2017, a non-commercial Java conference that I visited on 12 September 2017 in Hannover, Germany. The spoken language is German, but most of the presentations are written in English. In this article, I will list the links to the presentations I visited along with a small description.
Modularization: Stefan Tilkov
This presentation was a summary of the recent years' IT hype surrounding microservices. The term microservices implies something new, hip, and a solution of all IT architecture problems. It's presented as the state of the art solution for all further software systems.
The important information taken from the presentation was how to recognize and create a microservice and how to choose the right architecture for their implementation. The decision depends on many different dimensions and the concrete situations. In some cases, a domain can be defined as a microservice, while in another situation, many microservices can originate from one domain. On the other hand, microservices can have nothing in common with any particular domain.
In the presentation, four different patterns were mentioned about how to implement microservices in your system. A fifth pattern was also mentioned: a group of monoliths that are created by a previous monolith. Also, the selection of the right pattern depends on the system recommendations and its structure.
- Microservice unit
- Microservices types
It's all about bringing structure to a chaotic world of different views and definitions of microservices.
Riding the Hazelcast Jet-Stream: Christoph Engelbert
Hazelcast is a library that is used when you are running an application server that uses the Hazelcast module. With Hazelcast, it is easy to get a stream from the object pool and use it for many different operations. But when the operations get very complex and need a lot of time to be processed, then clustering gives a performance push. This clustering module is named Hazelcast Jet.
To enable clustering, the application needs to be split into DAG units, which are then executed on each cluster. This happens under the hood when using the Hazelcast Jet API. The low-level API was also presented with the note that it is more difficult to use because extra operations need to be implemented individually, as when using the high-level API.
As an example, a word counter was presented. The counting is split and sent to the clusters for the main work to be done, and after the counting is done, the result maps of the clusters are merged into a final result map, which, at the end, is displayed in the console.
- Introduction to Hazelcast Jet
- DAG — Directed Acyclic Graphs
- Hazelcast distribution streams instead of Java Streams
- High-level API example
- Chained Vertex calls
- Low-level API — DAG class
Brain Patterns in Software Development: Julia Dellinz and Jan Gentsch
The presenters, which also are consultants in agile software development, began the presentation with the anatomy of the human brain as the best IDE, describing its structure and which part of it is responsible for cognitive thinking.
It was also mentioned that we, as humans, want to consume less energy while thinking, and that is the reason why we fall back into old, known thinking routines — which is the opposite of what we should do when using agile software methods.
Several patterns were described where the software developer needs to rethink or to change their behavior and habits for better performance.
- Brain anatomy
- Human behavior vs. the Agile software development process
- Low energy state of the brain throws us into old patterns of thinking
- Different ways of thinking/processing
It's All About the Domain, Honey: Henning Schwentner
The main goal of this presentation was that the domain should be well-known before the software is implemented. Also, domain specific terms need to be learned well because some of them will be part of the system. Knowing the terminology will also help create faster communication with clients.
In this presentation, an example was taken from a shipping domain, where a system needs to be created that gives different information as a result, i.e. cartography to measure how deep water the water in the port of Hamburg. Also, in the example, many terms of the domain were mentioned, including one that was (correctly) mentioned twice because it belonged to two different contexts. This means that recognizing the terms and the contexts of the domain results in better software modeling and architecture.
- DDD — Domain-driven design
- Domain storytelling
- Strategy design
- DDD Community Deutschland
Java 9 Is Here!: Nicolai Parlog
Java 9 is out, and this presentation was dedicated exactly to it. Many new features were mentioned, like the modularization and what it means. See ho a JAR becomes a modularized JAR and why modularization is good in general. The final keyword doesn't need to be explicitly written anymore because any potential final variable will be seen as if it was declared as final. The Flow API, with the reactive streams, is also a new feature.
- Java 9
- Flow API
- New stream features
The Tool Is a Minor Matter: T. Winselmann and T. Garus
Presentation: Not published yet
The main story in this presentation was about a software team without QA. They had software quality problems and hoped to solve them by using a test framework. There were fewer problems, but not fewer than expected. Using another tool also didn't give the expected result.
Another idea was needed to solve the problem, and it resulted in a QA person who was responsible for the QA tools that operated on the written code. The next step was analyzing the code and giving feedback to the developers' many questions. The developers began to understand that the code should not only need to be workable, but also understandable for the tester. Overall, the changes could be seen as the beginnings of a QA process, which then gave them a much better result with higher software quality
- Unit tests
- QA process
Modern SQL: Markus Winand
Since the year 1999, SQL has evolved a great deal. It's added a lot of new features, but they are only implemented in a few popular databases. The new functions are not well-known and not often used by developers. Examples were shown of some of the more recent keywords that have come into the SQL syntax between 1999 and 2016, including the SQL keywords:
- GROUPING SETS
- OVER (PARTITION BY)
- WITHIN GROUP
- FETCH FIRST
Some of the new SQL functions were dedicated to Big Data analysis.
- SQL99, SQL2003, SQL2008, SQL2011, SQL2016
- Big Data Analysis
- SQL Keywords and examples
- Modern SQL
- SQL Performance
Open API Specification, AKA Swagger: Dennis Kieselhorst
One of the most-used REST API documentation languages is Swagger, as we have learned from this presentation. It is much more heavily used than RAML and the API Blueprint description standards. The presentation showed how a REST description can be created first with Swagger and then generate code, while also showing the opposite, where the code is generated first, and then the REST documentation is created as a Swagger dialect.
- REST API documentation
- API Blueprint
- From Swagger to code
- From code to Swagger
Improv Improves Agile Teams: Rüdiger Schnirring
The closing presentation was separated into several pieces/games with the goal of improving your Agile team by:
- Using rude words and defining a threshold for which words are "no-go."
- Synchronization thinking, where people using iterations of a term to arrive at saying the same word.
- Using a word from a given list to form the beginning of a sentence, then ending it with your own idea. That way, a funny story is created.
JavaNord is a one-day, non-commerce conference with four tracks organized from several Java User Groups (JUGs) located in the north of Germany. To top it off, it's free for the JUG members. Like other conferences, this was also very useful for visitors, with plenty of new info about frameworks, programming paradigms, methods of developing, and communicating.
The evening's social activity provided us with the opportunity to talk with other developers as well. They were excited about the conference and surprised by its organized nature. And at the end, one more motivating fact for visiting this conference is that, this time, the beer was free.
This time, I gave short descriptions for the talks. For some of them, I could guess the content from the title and description, but for others, it wasn't so obvious. Either way, it is always a good experience to learn something new.
Opinions expressed by DZone contributors are their own.