jChampions Conference

Abstract

One of the great advantages of Java was and is the static, strong type system. This helps millions of developers detect errors at compile time and makes development more robust and efficient. However, Java's distinction between primitive and reference types has been a heavy burden. The primitive data types introduced around 30 years ago for performance reasons do not integrate well with modern approaches such as generics, stream API or pattern matching.

Value Objects will provide a remedy and combine the advantages of both worlds. This will allow us to design immutable data types (state and behavior, but without their own identity) that behave like primitive data types. This not only increases performance and reduces memory consumption, it also increases readability and maintainability, as we can then define expressive yet performant types much more easily according to the ideas of DDD.

The project Valhalla has been working on this major change to Java's type system for around 10 years. There are a number of complex issues involved, such as how to handle default values and null values, the conversion of wrapper types, and the use of generic typing. In the summer of 2024, Java's Language architect Brian Goetz announced that after a long time, a breakthrough in implementation had been achieved. So let's take a look together at how value classes, null-restricted and nullable types, and extended primitive boxing will change the way we program in the future.

Value Objects - the next big thing in Java
Falk Sippach
Session URL: https://www.youtube.com/watch?v=7HU8uB8CmLA

Abstract

The presentation starts by addressing common testing pitfalls in distributed systems, like using in-memory databases, brittle mocks, and flaky async tests. It introduces a real-world fintech architecture with microservices, multiple databases, external APIs, and asynchronous workflows. The core strategy covers five areas: using real dependencies, avoiding in-memory DBs, virtualizing external systems, testing async flows properly, and establishing strong API governance. Through code examples and practical tips, the session shows how to build fast, reliable, and realistic test pipelines that boost confidence in complex systems.

Test Smarter, Not Harder: Achieving Confidence in Complex Distributed Systems
Elias Nogueira
Session URL: https://www.youtube.com/watch?v=8IZ1U0Zrncw

Abstract

To separate technical from domain code, architectural approaches like Hexagonal or Onion Architecture are currently all the rage. However, discussions about their semantic details and their mapping to the source code structure of software projects are at least equally ubiquitous.

How much abstraction and mapping between architectural concepts is needed? Is persistence metadata in the domain model heresy? Above all: what is the actual goal of the exercise, and: does it have to be so complicated?

We address these and other questions in a theoretical overview and by looking at concrete examples. We discuss the trade-offs of different approaches and how various tools and libraries help us to maintain the intended structure.

Domain-centric? Why Hexagonal- and Onion-Architecture are answers to the wrong question
Oliver Drotbohm
Session URL: https://www.youtube.com/watch?v=KoTBGbCk4_I

Abstract

🤖 AI code assistants are everywhere in Java development! They promise speed, but let's be honest, blindly accepting suggestions or falling into "vibe coding" often leads straight to confusing code and technical debt. 🤔 Sound familiar?

Want to actually master these tools? Ready to unlock truly productive AI collaboration and boost your speed without sacrificing quality? ✨ This talk reveals the 7 key habits and critical mindset shifts that separate frustrating AI interactions from game-changing results.

We'll skip the hype and focus on the practical secrets for working with your AI assistant smartly in your Java workflow.

The Golden Rule? Simple: whether you wrote the line or the AI did, you own the code. (git blame doesn't point to 'code assistant'! ❗) That's habit #1 – come to the talk to discover the other 6!

Knowing these habits is crucial, because shipping AI-assisted code with confidence requires more than just hitting 'accept'. Solid checks and a clear view of code quality are non-negotiable.

Join this session to learn the habits that will transform how you build Java code with AI. Walk away ready to make these tools work for you, faster and safer! ✅🚀

Seven Habits of Highly Effective AI Java Coding
Jonathan Vila López
Session URL: https://www.youtube.com/watch?v=3kBc0mE1MBw

Abstract

What’s wonderful about Java is that it's over 30 years old and still evolving—there’s a new release every six months! This means there are countless legacy systems that can be modernized to take advantage of new Java features and updated libraries. The primary driver for upgrading older systems is security—older versions of libraries often contain vulnerabilities. However, modernization can also bring additional benefits, such as improved performance and a better developer experience.

In this talk, we’ll explore a real-world project that modernized a mission-critical application using OpenRewrite, combined with deep expertise in technologies like Spring and Java/Jakarta EE. Join this session to gain insights that can help you modernize that aging back-office system in the corner—or the mission-critical app at the heart of your business.

Modernizing the Mission Critical with OpenRewrite and AI
Kito Mann
Session URL: https://www.youtube.com/watch?v=-aDxjaXT3FI

Tuesday, January 27 2026

Abstract

Since 2012, Pi4J has enabled Java to control electronic components connected to the Raspberry Pi's GPIO pins. However, both Java and the Raspberry Pi have evolved significantly since then. Supporting new hardware has been a challenge, requiring multiple implementations in the Pi4J library with a significant amount of complex code based on the Java Native Interface (JNI) and Java Native Access (JNA).

The Foreign Function & Memory (FFM) API, finalized in Java 22, promised to make such integrations with native code a lot easier. With Java reaching a new Long Term Support version, the Pi4J project bumped to Java 25 and makes full use of FFM!

In this talk, you’ll learn how this FFM implementation is much easier to support and achieves high performance due to less memory copying and less interop code. It will also help improve the Pi4J project by reducing dependencies, minimizing the JAR footprint, supporting additional protocols, and enhancing compatibility with more SoCs.

Through live demos, you will learn how to control LEDs, read buttons, interface with LCD displays, and gather sensor data. You'll see how FFM makes hardware interaction as natural as regular Java programming, and you will be ready to start your own experiments as soon as you arrive home.

Target audience: Java developers interested in IoT, embedded systems, and hardware programming. Basic Java knowledge is required, but no prior experience with Pi4J or electronics is needed.

The Wait is Over: Foreign Function & Memory (FFM) API brings modern Java to the Raspberry Pi
Frank Delporte
Session URL: https://www.youtube.com/watch?v=y5J5h2PPae0

Abstract

LLM agents are powerful, but no single one can cover every real-world task. This session shows what happens when you orchestrate multiple agents instead of relying on just one. We’ll explore four concrete experiments: running multiple agents in parallel with LangChain4j and Spring AI; manually coordinating Gemini CLI, Codex CLI, and Claude Code on the same code base; wrapping Gemini in an MCP server so it can be invoked by other tools; and creating a Claude Code sub-agent that delegates to Gemini while conserving context window tokens. You’ll see where orchestration pays off, where it gets messy, and what it suggests about the future of applied multi-agent AI.

When One Agent Isn’t Enough: Experiments with Multi-Agent AI
Kenneth Kousen
Session URL: https://www.youtube.com/watch?v=ns4EMx-g_iw

Abstract

Virtual threads, pattern matching, garbage collector, value types, integrity by default, AOT. So much new cool stuff packed in this brand new Java 25.

Come have a look with me. Live coded.

Java 25 (LTS): Virtually the best version ever
Henri Tremblay
Session URL: https://www.youtube.com/watch?v=iUT8JRnQZbs

Abstract

Java has been around for decades, and so has your codebase. Keeping up with the latest Java versions, frameworks, and best practices isn't just about staying current—it’s about making your applications easier to maintain, faster to develop, and more attractive to both developers and customers. But where do you start?

In this session, we’ll take a pragmatic approach to modernizing Java applications with minimal disruption and maximum value. We’ll cover:

Upgrading Java versions with OpenRewrite – Reduce technical debt, adopt the latest language features, and lower maintenance costs with automated refactoring.
Moving from Swing to Vaadin – Preserve your business logic while transitioning from legacy desktop applications to modern web frontends.
The human factor – Modernization isn’t just about code; it’s about people. Learn how to keep your current team engaged, avoid unnecessary retraining, and make your project more attractive to new talent.

With over two decades of Java experience, I’ll share hard-earned insights and real-world strategies that you can start applying today. If your Java applications feel stuck in the past, this talk will show you how to bring them into the future—without rewriting everything from scratch.

Java Modernization: Breathe New Life into Your Codebase Without Breaking the Bank
Richard Fichtner
Session URL: https://www.youtube.com/watch?v=HDB06Fmmgjs

Abstract

Let’s abuse the tools! Everyone knows Quarkus is computationally efficient, expressive, and rock-solid for production. But did you know that we can use Quarkus efficiency to build applications that shouldn’t go anywhere *near* production?

In this demo-driven session, Holly will put the joy into “developer joy”. She’ll show you all sorts of things you can do with Quarkus that you probably shouldn’t:

- Build an LLM-powered app that’s *guaranteed* to hallucinate, because you can do more than you think with guardrails, and truth is so boring
- Write your business code in rockstarlang, because everything should be a hair metal ballad
- Use Minecraft as your observability client, because the LGTM stack doesn’t have enough explosions
- Write a CLI for generating memes faster, because everything is better on the command-line
- Benchmark an application against a grapefruit, because metric units aren’t tasty

Business value? Learning? If you insist. As well as absurd demos, you’ll leave this session with a deeper understanding of how to get the most out of Quarkus and Java. There will be Quarkus best practices, powerful integrations, and nifty use cases alongside the silly explosions and grapefruit.

Six and a half ridiculous things to do with Quarkus
Holly Cummins
Session URL: https://www.youtube.com/watch?v=hdcaq7pN-vo

Abstract

Every Christmas Eve, Santa faces a monumental challenge: delivering gifts to millions of children around the world in just one night. There’s no time for detours, and a well-crafted plan is essential!

In this talk, we’ll help Santa find the optimal travel route for his journey using Timefold, an open-source AI solver. By setting up some basic domain classes, you'll be able to tackle vehicle routing problems without getting lost in the magic (aka math).
Through a series of live demos, you'll see practical examples in action and leave with a powerful new tool in your problem-solving toolbox.

So join in and let's use our favorite programming language to make sure everyone gets their presents under the Christmas tree!

Optimizing Santa's travels in Java with Timefold
Tom Cools
Session URL: https://www.youtube.com/watch?v=DjPUvFXfkas

Abstract

Modern Java has evolved into a powerful, expressive language by quietly adopting the best ideas from its peers without compromising its core principles of readability, safety, and performance. In this talk, we'll explore how Java 25 now competes head-to-head with languages like Kotlin, Scala, Rust, and Go.

- Pattern Matching that's as expressive as Scala and Rust
- Virtual Threads, Java's lightweight concurrency mode, inspired by goroutines
- Structured Concurrency for safer, more predictable parallel programming
- Records for concise and immutable data modelling, akin to Kotlin's data classes
- Foreign Function & Memory API as a modern, safer alternative to JNI, rivalling Rust’s FFI

If you’ve ever dismissed Java as too verbose or outdated, this session will change your mind. See how Java 25 isn’t just catching up; it’s redefining what modern Java can be.

Old Dog, New Tricks: The Java 25 Reinvention
Bazlur Rahman
Session URL: https://www.youtube.com/watch?v=WKXm8gHLN28