Featured Sessions

Testing is “the right thing”… right up until your test cases depend on data, a database state, or that one PL/SQL procedure that fails out of your machine. In The road to JUnit 6, Marc Philipp—JUnit Team Lead, Java Champion, and long-time driver of the JUnit ecosystem—walks you through a practical toolbox for reliable, reproducible, data-driven tests in real-world Java projects.

You’ll learn how to use Testcontainers for clean environments, manage and verify database state with DbUnit and Database Rider, and even test PL/SQL logic—so your tests cover what matters and stay stable over time.

If you’ve ever thought “our tests are flaky, but it’s complicated,” this session is your path to making them boring—in the best possible way.

Nullability in Java has a long and… let’s say “well-documented” history. We’ve had annotation-based approaches, IDE hints, framework conventions, and enough @Nullable debates to power a small starship. Now JSpecify, paired with static code analysis, is the newest serious attempt to make null contracts explicit and useful across libraries and applications—at least until Java’s future “Null-Restricted and Nullable Types” work fully lands.

In this session, Michael Simons (Senior Staff Engineer at Neo4j, Java Champion, author, and longtime community builder) takes you on a fast but grounded tour: you’ll learn how to reduce NPE risk across module and library boundaries, when annotations actually improve safety, and where they can create a false sense of security. Michael also covers what to consider as a library author vs. application developer, so you can decide if/when adopting JSpecify is worth it for your codebase—and how it helps you stay future-ready for Java’s upcoming null-related language work.

Java runs everywhere—but what actually happens after you hit compile? In this session, Gerrit Grunwald (Senior Developer Advocate at Azul, Java Champion) takes you on a guided tour through the JVM: from source code to bytecode, from interpretation to JIT-compiled machine code.

The value for you as a developer: you’ll build a practical mental model of what the JVM does with your code, so performance issues, “weird” latency spikes, and memory behavior become easier to reason about. You’ll learn what gets interpreted vs. compiled (and why), when optimizations kick in, and the basics of JVM memory management—knowledge you can apply immediately when profiling, tuning, or making architecture decisions.

Modern Java is packed with powerful features—but if you’re new to recent releases (or Java in general), terms like Structured Concurrency or Stream Gatherers can sound like a trailer for a sequel you haven’t watched yet. In this session, Marit van Dijk (Java Champion, Developer Advocate at JetBrains) and Piotr Przybyl (Senior Developer Advocate at Elastic, Java Champion) make the “modern Java” landscape feel approachable, practical, and genuinely fun.

They’ll explain which new features solve real day-to-day problems, when they’re the right tool, and how to avoid common traps. You’ll also see how to use your IDE to explore, refactor, and experiment safely—so you can bring modern Java into your codebase (or side project) with confidence.

You’ll leave with a clearer mental model of modern Java, a handful of ready-to-try examples, and the motivation to level up your everyday coding—starting the very next day.

Production performance problems don’t show up politely in a microbenchmark—they arrive as slow endpoints, noisy neighbors, thread contention, and “why is the CPU on fire?” at the worst possible time. In this code-heavy session, Yuriy Bezsonov (Senior Solutions Architect, AWS) and Sascha Möllering (Principal Specialist SA for Containers, AWS) demonstrate how to build a production-ready performance diagnostics pipeline that combines proven open-source tooling with AI-driven analysis and remediation.

You’ll leave with a practical playbook you can use at work or in side projects: how to capture the right signals, spot CPU/contestion/threading bottlenecks faster, and turn findings into concrete code-level optimizations. The demos run end-to-end (incl. Kubernetes), and you’ll get source code + prompt templates—so you can apply the approach immediately and stay future-ready as AI-assisted diagnostics becomes standard.