Sven Woltmann
Java trainer, consultant, speaker – author of HappyCoders.eu
Java-Trainer, Consultant, Speaker – Autor von HappyCoders.eu
Berlin, Germany
Actions
Sven Woltmann is a seasoned Java expert. As a consultant and trainer, he helps companies modernize and future-proof their Java applications – through workshops, targeted training on modern Java features, and ongoing support during implementation. He regularly shares his expertise at conferences, in videos, through his newsletter, and on his blog, HappyCoders.eu.
Sven Woltmann ist Java-Experte der ersten Stunde. Als Berater und Trainer hilft er Unternehmen, ihre Java-Anwendungen zu modernisieren und zukunftssicher zu machen – mit Workshops, gezielten Trainings zu modernen Java-Features und kontinuierlicher Begleitung bei der Umsetzung. Sein Wissen teilt er regelmäßig auf Konferenzen, in Videos, auf seinem Newsletter und auf seinem Blog HappyCoders.eu.
Area of Expertise
Topics
Stream Gatherers: Write Your Own Powerful Stream Operations! en de
The Java Stream API was released in March 2014 with Java 8, giving us an indispensable tool for data processing.
However, the limited set of intermediate operations – `filter`, `map`, `flatMap`, `mapMulti`, `distinct`, `sorted`, `peak`, `limit`, `skip`, `takeWhile`, and `dropWhile` – means that more complex data transformations cannot be expressed directly using the Stream API.
Operations such as `window` and `fold`, among many others frequently requested by the community, are missing.
Instead of adding all these operations directly to the Stream interface, the JDK team developed a new API. This API is used internally within the JDK to provide highly requested intermediate operations and also allows developers to implement their own custom operations.
This new API is called Stream Gatherers. It was first introduced as a preview feature (JEP 461) in Java 22 in March 2024 – exactly ten years after the original Stream API debut. The API was finalized in Java 24 (JEP 485).
In this talk, you’ll learn – both in theory and through hands-on live coding – what Stream Gatherers are and how they work, which Gatherers are already available in the JDK and how to use them effectively, how to implement your own Gatherers, and where the limitations of the new API lie.
This talk has been presented at:
- betterCode() Java 2024
- JUG Hamburg
- entwickler.de: 30 Years of Java
- JavaLand 2025 (listed as a Top Talk)
- Java Forum Stuttgart 2025
Stream Gatherers: Schreibt eure eigenen, leistungsstarken Stream-Operationen! en de
Die Java-Stream-API wurde mit Java 8 im März 2014 veröffentlicht und hat uns ein unverzichtbares Werkzeug an die Hand gegeben, um Daten zu verarbeiten.
Doch der begrenzte Satz an intermediären Operationen – `filter`, `map`, `flatMap`, `mapMulti`, `distinct`, `sorted`, `peak`, `limit`, `skip`, `takeWhile` und `dropWhile` – führt dazu, dass komplexere Datentransformationen durch die Stream-API nicht ausgedrückt werden können.
Es fehlen z. B. Operationen wie `window` und `fold` und zahlreiche mehr, wenn man sich die Feature-Requests der Community ansieht.
Anstatt nun all diese Operationen ins Stream-Interface zu integrieren, entwickelte das JDK-Team eine neue API, die zum einen im JDK selbst genutzt wird, um heiß begehrte intermediäre Operationen bereitzustellen, und mit der zum anderen Entwicklerinnen und Entwickler ihre eigenen Operationen implementieren können.
Diese neue API heißt „Stream Gatherers“ und wurde in Java 22 im März 2024, also genau zehn Jahre nach der Einführung der Stream-API, zum ersten mal als Preview-Feature (JEP 461) veröffentlicht. In Java 24 wurde die neue API finalisiert (JEP 485).
In diesem Talk erfahrt ihr in Theorie und Praxis (inklusive Live-Coding), was Stream Gatherers sind und wie sie funktionieren, welche Gatherer im JDK bereits verfügbar sind und wie ihr sie effektiv einsetzt, wie ihr selbst eigene Gatherer implementieren könnt und wo die Grenzen der neuen API liegen.
Ich habe den Vortrag auf folgenden Konferenzen / JUGs gehalten:
- betterCode() Java 2024
- JUG Hamburg
- entwickler.de: 30 Jahre Java
- JavaLand 2025 (als Top-Vortrag gelistet)
- Java Forum Stuttgart 2025
Hexagonal Architecture: Building Robust Software with Interfaces Instead of Layers en de
We’ve all experienced this: the older and larger an application becomes, the harder and more expensive it gets to maintain and extend. The widely used layered architecture often falls short as a solution: direct and indirect dependencies of all layers on the database and other infrastructure components tend to blur the boundaries between layers and intertwine technical and business code.
Hexagonal Architecture places business logic at the center, isolating technical details behind interfaces (ports) and adapters. This separation allows business and technical code to be developed and tested independently.
Starting from the goals of software architecture and a critical look at traditional layered architecture, we’ll take a deep dive into Hexagonal Architecture. You’ll learn how the Dependency Rule ensures there are no dependencies from business to technical code – and how the application core can still access infrastructure when needed. Does Hexagonal Architecture actually fulfill the goals of a solid software architecture? What challenges does it introduce? How does it compare to Onion and Clean Architecture, and what synergies emerge when combined with Microservices and Domain-Driven Design?
Armed with these insights, you’ll be able to improve the quality and longevity of your software projects and respond more quickly to new requirements in the future.
This talk has been presented at:
- JUG Darmstadt
- JavaLand 2024
- JUG Berlin
- JUG Saxony Day 2025
Hexagonale Architektur: Robuste Software dank Schnittstellen statt Schichten en de
Wir alle kennen diese Situation: Je älter und größer eine Anwendung wird, desto aufwendiger und teurer wird es, sie zu erweitern und zu warten. Die verbreitete Schichtenarchitektur ist als Lösungsansatz unzureichend: Direkte und indirekte Abhängigkeiten aller Schichten zur Datenbank und anderen Infrastrukturkomponenten führen oft zu einer Aufweichung der Schichtengrenzen und einer Verflechtung von technischem und fachlichem Code.
Hexagonale Architektur rückt die Geschäftslogik ins Zentrum, und technische Details werden als Adapter hinter Schnittstellen (Ports) isoliert. Fachlicher und technischer Code können so unabhängig voneinander entwickelt und getestet werden.
Ausgehend von den Zielen einer Softwarearchitektur und einem kritischen Blick auf die Schichtenarchitektur, schauen wir uns die hexagonale Architektur im Detail an. Ihr erfahrt, wie die Dependency Rule sicherstellt, dass es keine Abhängigkeiten von fachlichem zu technischem Code gibt und wie der Anwendungskern trotzdem auf die Infrastruktur zugreifen kann. Erfüllt die hexagonale Architektur die Ziele einer Softwarearchitektur? Welche Herausforderungen bringt sie mit sich? Wie unterscheidet sie sich von Onion und Clean Architecture, und welche Synergien ergeben sich im Zusammenspiel mit Microservices und Domain-Driven Design?
Mit neuem Wissen gerüstet, könnt ihr die Qualität und Lebensdauer eurer Softwareprojekte steigern und in Zukunft schneller auf neue Anforderungen reagieren.
Ich habe den Vortrag auf folgenden Konferenzen / JUGs gehalten:
- JUG Darmstadt
- JavaLand 2024
- JUG Berlin
- JUG Saxony Day 2025
From Compressed OOP to Compact Headers: JVM Internals Explained en de
With Java 25, a major change in the memory layout of objects is arriving: Compact Object Headers. In this talk, supported by numerous graphics that make complex concepts easy to grasp, you’ll learn what’s behind this innovation.
We’ll use Compact Object Headers as a starting point to explore the world of object headers, object pointers, and class pointers. What exactly are OOPs (Ordinary Object Pointers), and how do Compressed OOPs work on 64-bit systems? How are classic 128-bit object headers structured – and how can they be compressed to 96 or even 64 bits?
You’ll discover what the Mark Word is, how it’s structured, what role it plays in locking – and how this relates to the pinning of virtual threads. We’ll look at the evolution from legacy locking to lightweight locking, and how this very evolution paved the way for smaller headers through Project Lilliput.
Finally, you’ll learn why smaller objects don’t just save memory, but can also noticeably improve your application’s performance.
This talk is aimed at developers who not only write Java code but also want to understand the JVM mechanisms under the hood.
Basic Java knowledge is sufficient. No prior experience with JVM internals is required – all concepts will be explained clearly and with practical examples.
So far, I have given (or will give) this talk at two online conferences:
- entwickler.de: Java 25 Unboxed
- betterCode() Java 2025
Von Compressed OOP bis Compact Headers: JVM-Interna verständlich erklärt en de
Mit Java 25 hält eine tiefgreifende Änderung im Speicherlayout von Objekten Einzug: Compact Object Headers. In diesem Vortrag erfährst du – unterstützt durch zahlreiche Grafiken, die komplexe Zusammenhänge anschaulich machen – was sich dahinter verbirgt.
Wir nutzen Compact Object Headers als Einstieg, um die Welt der Object Headers, Object Pointers und Class Pointers zu erkunden: Was genau sind OOPs (Ordinary Object Pointers), und wie funktionieren Compressed OOPs auf 64-Bit-Systemen? Wie sind klassische 128-Bit-Object-Header aufgebaut – und wie lassen sie sich auf 96 oder sogar 64 Bit komprimieren?
Du erfährst, was das Mark Word ist, wie es aufgebaut ist, welche Rolle es beim Locking spielt – und was das mit dem Pinning von Virtual Threads zu tun hat. Wir werfen einen Blick auf die Entwicklung vom Legacy Locking zum Lightweight Locking – und wie genau diese Evolution die Verkleinerung des Headers durch Project Lilliput erst möglich gemacht hat.
Und nicht zuletzt erfährst du, warum kleinere Objekte nicht nur Speicher sparen, sondern auch die Performance deiner Anwendungen spürbar verbessern können.
Der Vortrag richtet sich an EntwicklerInnen, die nicht nur mit Java entwickeln, sondern auch die JVM-Mechanismen unter der Haube verstehen wollen.
Für den Vortrag sind grundlegende Java-Kenntnisse ausreichend. Vorkenntnisse zu JVM-Interna sind nicht notwendig – alle Konzepte werden anschaulich und praxisnah erklärt.
Ich habe den Vortrag bisher auf zwei Online-Konferenzen gehalten (bzw. werde ihn halten):
- entwickler.de: Java 25 Unboxed
- betterCode() Java 2025
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top