jChampions Conference

Sessions

* Please note that there may be changes to the time a session is presented.

Thursday, January 22 2026

Modular RAG Architectures with Java and Spring AI

Thomas Vitale

Spec-driven Development: How AI Changed Everything (And Nothing)
Simon Martinelli

Abstract

There are many initiatives inside the OpenJDK that are revolutionizing the way our Java applications behave. Project Leyden accelerates peak performance by improving ahead of time caching. But, do you know how to use it with your application?

On this session we will discuss what Leyden is, what is the state of art of the ahead of time cache, and showcase a few examples. We will prove (with potential demo effect!) that Leyden decreases warm-up time, and present the tools you can use to optimize your application!

Ahead of time, the final frontier
María Arias de Reyna Dominguez
Andrew Dinn

Abstract

As Large Language Models (LLMs) revolutionize application development, Java developers face a critical challenge: how to securely and efficiently connect these AI models with enterprise data and tools.

The Model Context Protocol (MCP) offers a practical solution by providing a standardized approach for integrating AI capabilities into Java applications while maintaining enterprise-grade security and scalability.

Through live coding demonstrations, we'll explore how to leverage Java's MCP implementation to build powerful AI-enabled applications. Starting with basic setup and configuration, we'll progress to building custom MCP servers using Java and create practical features that combine the power of LLMs with Java's robust ecosystem. You'll see firsthand how to connect your Java applications to your favorite MCP enabled clients and other AI tools while maintaining control over your data and infrastructure.

Building and Securing MCP Servers in Java

Dan Vega

Abstract

Cloud Native Buildpacks make it easier for developers to create container images, offering a seamless experience with built-in features such as rebasing, reproducibility, and support for multiple entry points. In this talk, we'll start by covering the basics of Buildpacks, looking at their architecture and the benefits they bring compared to traditional methods of building container images.

We’ll then explore the lifecycle component, which is the central binary of Cloud Native Buildpacks. This part will reveal how it manages the conversion of source code into OCI images and oversees the various stages of the build process, including detection, installation, and export.

We will also discuss the Paketo Buildpacks project, emphasizing its flexibility and community focus. This section will show how Paketo improves the developer experience by offering a curated selection of buildpacks that make configuration easier and enhance performance. Additionally, we'll share real-world examples of how organizations are using Buildpacks to streamline their CI/CD pipelines and speed up their deployment cycles. To wrap up, we’ll go over some best practices for integrating Buildpacks into your workflows, providing tips on maximizing their features for better performance and security.

Understanding Buildpacks: Delving Deep into Their Functionality
Patrick Baumgartner

Abstract

With today's computers, it takes trillions of years to crack an RSA-2048 encrypted private key. However, experts predict that by 2035, quantum computers will be able to crack RSA-2048 in only a few days. Malicious agents are already harvesting our sensitive communications in the hope of decrypting them once quantum computing hardware becomes available.

We need schemes for encrypting data that quantum computers can't crack. Any such scheme is an example of Post-Quantum Cryptography, and the US government's standards organization (NIST) has endorsed several such algorithms. Two of the algorithms were released as features in Java 24.

- Java's Quantum-Resistant Module-Lattice-Based Key Encapsulation Mechanism (JEP 496) secures symmetric keys over insecure communication channels.
- Java's Quantum-Resistant Module-Lattice-Based Digital Signature Algorithm (JEP 497) detects unauthorized modifications to data and authenticates the identity of signatories.

Both algorithms are designed to be secure against future quantum computing attacks.

This talk examines Java's entry into the post-quantum era.

Post-Quantum Cryptography in Java
Barry Burd

Abstract

Many senior Java developers dream of becoming respected experts — sought after by companies, invited to speak, and known for their contributions. But few know how to take the next step.

In this talk, you'll learn how to apply the Deliberate REPUTATION formula — a framework built from years of experience helping Java developers become recognized leaders in their field. We’ll cover how to define your focus, build visibility through open source and community, take meaningful action, and avoid the common traps that stall your growth.

If you're a seasoned developer who wants more autonomy, better opportunities, and to make a lasting impact in the Java world, this session is your roadmap.

Growing Beyond Senior: Build Influence and Reputation Through Java, Open Source, and Community
Bruno Souza

Friday, January 23 2026

Abstract

Testing is hard, which is why developers tend to avoid it. Testing non-deterministic things is even harder, which is unfortunate, since we're all writing AI-infused applications, and AI models are notoriously non-deterministic. What happens when the applications start using advanced features, such as RAG, tools, and agents? How do you test these applications? There must be some tools, technologies, and practices out there that can help, while not costing your organization lots of money!

Join Java Champions Oleg & Eric in this session as they explore some of these tools & technologies, such as Testcontainers, LangChain4j, Quarkus, and Ollama. They’ll bring together Oleg’s Testcontainers knowledge and Eric’s testing obsessions, getting hands-on and show how you can incorporate these tools and technologies into your inner and outer loop processes.

You’ll see how effortlessly Quarkus integrates with Testcontainers, and how Testcontainers can be used in conjunction with popular LLMs when writing tests. You’ll also learn about how to use containers to extend your testing into your CI environments, so you can always be sure that if your tests are green you’re good to go!

Non-deterministic? No problem! You can test it!
Eric Deandrea
Oleg Selajev

Abstract

There is no universally agreed definition of what an AI agent is. In practice though, several patterns are emerging. These patterns demonstrate the coordination and integration of multiple AI services to build sophisticated Agentic AI systems capable of handling intricate tasks.

These Agentic Systems architectures can be grouped in 2 main categories: workflows, where LLMs and tools are orchestrated through predefined code paths, and agents, where LLMs dynamically direct their own processes and tool usage, maintaining control over how they execute tasks.

Testing these Agentic Systems architectures is a big challenge for the adoption in mission critical scenarios. This is mainly due to their not completely deterministic nature.

The goal of this talk is to give a theoretical overview of Agentic AI in general and these patterns in particular. We will discuss their differences and range of applicability and show with practical examples how they can be easily implemented and tested. We’ll use Quarkus and its LangChain4j extension, but the concepts are universal.

Agentic AI Patterns

Mario Fusco

Abstract

We live in a complicated world and we are beginning to see that today’s generative AI systems are simply not well equipped to handle the increased complexity that is found especially in business workflows and transactions. Event-driven architectures and multi-agent systems offer a promising solution by enabling real-time processing, decentralized decision-making, and enhanced adaptability.

This presentation proposes an in-depth exploration of how event-driven architectures and multi-agent systems can be leveraged to design and implement complex workflows in generative AI. By combining the real-time responsiveness of event-driven systems with the collaborative intelligence of multi-agent architectures, we can create highly adaptive, efficient, and scalable AI systems. This presentation will delve into the theoretical foundations, practical applications, and benefits of integrating these approaches in the context of generative AI.

Harnessing Event-Driven and Multi-Agent Architectures for Complex Workflows in Generative AI System

Mary Grygleski

Abstract

Since Java 14, the Java switch and instanceof statements have been enhanced, in multiple phases, to support pattern matching and a "data-oriented" programming style. In this presentation, I explore when this programming style is beneficial, and why. (Spoiler: Not as often as one might think from Oracle's presentations, but when it does apply, it is truly useful.) I describe the syntax of pattern matching, as it has evolved, and show how it will be further enhanced in upcoming versions of Java. I warn of corner cases of the switch syntax where modern usage clashes with legacy behavior. I conclude with a set of rules when to use pattern matching and "data orientation" now, how to prepare for future enhancements, and when to stay away.

Effective Pattern Matching in Java
Cay Horstmann

Abstract

Designing APIs is an art, a creative exercise. Getting it right for the present is hard; getting it right for the future is even harder.

This talk explores designing resilient Java APIs for upward compatibility, consumability, and flexibility.

We’ll discuss the practicalities of ideas like encapsulation and inheritance, look at broader elements like consistency, effective communication of intent, and cover concepts like the Open-Closed Principle, Semantic Versioning, and other elements that are essential for seamless API evolution.

We’ll review real-world examples, Java gotchas, the latest Java API capabilities, API Check tools, and data and take a look at what Maven Central tells us about the challenge we all face (and just how good we collectively are).

Amazingly, good API design not only helps with evolving for the future, it makes the API more secure and reduces maintenance overheads - all while remaining flexible and consumable.

Time to break those bad design habits before they begin

Future-Proofing Java: The Art of Crafting Resilient APIs
Steve Poole

Abstract

Get hands-on experience with integrating AI capabilities into your Angular and Java projects. This talk will provide a step-by-step guide to setting up the integration, handling API calls, and processing AI-generated data. We'll focus on practical examples and real-world use cases to demonstrate how to create intelligent features that enhance your web applications.

Building the Next Generation of Web Apps: Angular, Java, and the AI Revolution
Loiane Groner

Abstract

Let's be honest: many of our so-called "REST" APIs aren't REST. They're just JSON-RPC over HTTP, with versioning challenges, brittle integrations, clumsy error handling, and a maintenance burden we all know too well.

Let's do something about this! We’ll go straight to the patterns that matter in production, tackling the real-world challenges head-on: building evolvable versioning strategies, designing sane error responses, providing clear API contracts, and demystifying the practical use of hypermedia (HATEOAS).

You'll leave with practical, battle-tested approaches for building APIs that are maintainable and scalable. We'll also discuss when to use REST and when alternatives like GraphQL or gRPC are a better tool for the job. All demos use Jakarta EE and MicroProfile, but the patterns can be applied to any modern web stack of your choosing.

API = Some REST and HTTP, right? RIGHT?!
Rustam Mehmandarov

Monday, January 26 2026

Abstract

Today's AI agents are technological marvels, but their non-deterministic, "black box" nature makes them a risky foundation for industrial-scale software development. It's time to move beyond agent-based improvisation and embrace engineering discipline.

This talk introduces a fundamentally new architecture and an open-source tool, JAIG (Java AI-powered Code Generator), designed to tame the chaos of AI. We shift the paradigm from "chatting with an agent" to orchestrating deterministic, versionable, and testable workflows. We will demonstrate how our novel AI Interview process transforms ambiguous requirements into executable blueprints, and how these blueprints drive a transparent, reproducible code generation process.

Beyond Agents: A New Architecture for Reproducible Code Generation Workflows
Catalin Tudose
Vladimir Sonkin

Abstract

Java, the runtime, likes memory.
It is a fact well known to those who know it well, that subtle differences in code, can lead to drastic changes to applications memory and runtime profiles.
I’ll take you through the memory lane part of my work, and show how do I approach analysis, problems and troubleshooting. Tools, what information can they surface, and how to navigate back to the code.
Techniques and libraries, how do they affect what the application does. Feel invited if you believe troubleshooting memory in Java is “magic”, or “only tuning the GC can save us”.

Scooby RAM, where are you?
Andrzej Grzesik

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

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

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

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

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

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

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

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

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

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

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

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