Since switching to the six-month release cycle, Java has been evolving at a pace that hardly anyone can fully keep up with. Between Java 11 and Java 25, we’ve seen records, sealed classes, virtual threads, pattern matching, stream gatherers, scoped values, AOT compilation, and much more—features that are fundamentally changing the way Java is written and run.
The choice is yours:
- Module 1 – Java 12 through 17 (1 day, bookable individually): Records, sealed classes, pattern matching for ‘instanceof’, switch expressions, and text blocks.
- Module 2 – Java 18 to 21 (2 days, bookable individually): Virtual threads (including pitfalls and observability), pattern matching for ‘switch’, record patterns, and sequenced collections.
- Module 3 – Java 22 to 25 + Outlook on Java 26 (2 days, bookable individually): Scoped Values, Structured Concurrency, Stream Gatherers, AOT, FFM API, and the latest language updates.
- All three modules as a complete package (5 days): The complete journey from Java 12 to 25.
This training course systematically brings experienced Java developers up to speed. It’s not just a superficial overview, but a well-thought-out structure: The three modules build on one another, language features are taught in meaningful combinations, and each block ends with a hands-on exercise. You’ll leave the training not only with knowledge, but also with the tools you need to apply modern Java features in real-world projects—and to make informed decisions when migrating your applications.
Agenda
Module 1 – Java 12 through 17
- Switch Expressions + Text Blocks + Helpful NullPointerExceptions
- Records + Pattern Matching for ‘instanceof’
- Sealed Classes + API Highlights
- GC, Performance, Strong Encapsulation + Migration
Module 2 – Java 18 through 21
Day 1
- Virtual Threads: Architecture and API
- Virtual Threads: Practical Application and Pitfalls
- Observability & Virtual Threads
- Pattern Matching for switch
Day 2
- Record Patterns + The Power of Combinations
- Sequenced Collections + API Extensions
- GC, Performance & Other Topics
- Deprecations + Migration + Wrap-up
Module 3 – Java 22 to 25 + Outlook on Java 26
Day 1
- Compact Source Files + Module Imports + Multi-File Programs
- Markdown Javadoc + Unnamed Variables & Patterns + Flexible Constructors
- Stream Gatherers
- Project Loom: Scoped Values
Day 2
- Project Loom: Structured Concurrency
- Performance & GC
- FFM API + Integrity by Default + Cryptography
- Minor API Extensions + Outlook on Java 26 + Wrap-up
Your Benefits
Understand which features from Java 12–25 will immediately improve your day-to-day work as a developer—and use them confidently.
Migrate applications from Java 11 through 17 and 21 all the way to 25 with a clear strategy and an understanding of breaking changes.
Use virtual threads correctly: with an understanding of architecture, pitfalls, and observability—instead of half-baked copy-and-paste.
Model domains precisely and expressively with records, sealed classes, and pattern matching—right in Java.
Write better, more readable code using records, pattern matching, text blocks, unnamed variables, and stream gatherers.
Choose the right garbage collector for your use case and understand what has changed in the GC landscape since Java 11.
Reduce startup times with AOT class loading and understand how Project Leyden fundamentally improves JVM startup and warmup.
Replace ThreadLocal with scoped values and design concurrent applications that are structured and fault-tolerant using structured concurrency.
Audience
This training is aimed at experienced Java developers who are actively working on a Java 11 or Java 17 codebase and want to bring their skills up to date. Developers who are already using Java 21 and preparing to make the leap to Java 25 will also find Module 3 to be just what they need. A solid foundation in Java is required; however, the features of each Java version covered will be introduced from the ground up—no prior knowledge is required.
Those who book only individual modules should note the prerequisites: Module 2 requires familiarity with the language features covered in Module 1 (records, sealed classes); Module 3 builds on the virtual threads foundation established in Module 2.
Training Objectives
Using the New Language Features of Java 12–25 Safely
Targetedly Reducing Boilerplate Code Using Records, Pattern Matching, and Modern API Methods
Expressing Domain Models Using Sealed Interfaces and Records as Algebraic Data Types
Understand virtual threads, use them correctly, and monitor and debug them with appropriate tools
Replace ThreadLocal with scoped values and coordinate concurrent tasks in a structured manner using structured concurrency
Classify GC innovations from Java 12–25 and select the appropriate garbage collector for your specific requirements
Use AOT class loading and AOT method profiling to reduce JVM startup times
Be familiar with deprecations and breaking changes from Java 11 through 25 and approach migrations in a structured manner
Safely access native libraries using the Foreign Function & Memory API—without JNI
Your Trainers
Falk Sippach
embarc
Architecture reviews, Java expert
- Agile Software Architecture
- Application Programming Interfaces
- CPSA Foundation Level
- Documentation-as-Code
- Evolution and Improvement of software architectures
- Fantastic diagrams
- Flexible architectures
- Modern Java Masterclass
- Spring Modulith
As a trainer, consultant and architect, Falk is always on the lookout for the spark of passion that he can ignite in his participants, customers and colleagues. He has been supporting mostly agile software development projects in the Java environment for over 15 years, initially as a developer and later as a project manager, architect and coach. Falk is convinced that lifelong learning is the prerequisite for professional self-development and lasting enjoyment in what you do. Despite his enthusiasm for new things, he always keeps an eye on people and established structures in order to develop balanced solutions. As an active member of the community, he likes to share his knowledge in articles, blog posts and presentations at conferences or user group meetings and supports the organization of various specialist events. Video: What is Documentation as Code? Falk explains it to you in the stream with Lisa Moritz.
Sven Woltmann
HappyCoders, Java-Experte
Java
- Modern Java Masterclass
Sven Woltmann has been working with Java for over 30 years—as a developer, architect, trainer, author, and speaker. With HappyCoders.eu, he runs one of the most widely read Java blogs in the German-speaking world. As a conference and JUG speaker, he is known for explaining even complex technical concepts in a clear and practical way. In his training sessions, he combines a deep technical understanding with many years of project experience—with the goal of ensuring that what participants learn can be immediately applied in real-world projects.