[Talk::Overflow #26] jChampions Conference 2026 Tech Talks

jChampions Conference 2026 ran from January 22–27 across four days of online sessions, bringing together Java Champions from around the world. The format is uniquely distributed — no venue, no hallway track, just dense technical talks delivered to engineers tuning in from wherever they are. This year’s edition arrived at a pivotal moment: Java 25 is now an LTS release, AI-assisted development has moved from curiosity to daily practice, and the question of “how do you actually build with LLMs in Java?” is no longer hypothetical.

What the conference revealed: the Java ecosystem is not sitting out the AI era. From Spring AI RAG pipelines to MCP servers, from spec-driven code generation to multi-agent orchestration, the community is actively building the tooling and patterns that let Java stay relevant in the LLM-infused application landscape — without abandoning the engineering discipline that makes Java trustworthy at scale.

Thomas Vitale walks through building production-ready RAG (Retrieval-Augmented Generation) pipelines in Java using Spring AI. The talk is structured around five stages: data indexing, query analysis, retrieval, augmentation, and evaluation — making it one of the most methodical treatments of RAG you’ll find in the Java ecosystem. What sets this apart from most AI integration talks is the emphasis on modular architecture: each stage is independently swappable, testable, and observable. Vitale addresses the real pain point that most RAG demos skip — evaluation — showing how to measure document relevance and model output quality iteratively. If your team is wiring an enterprise Java app to an LLM and wants it to behave reliably in production, this is the reference talk.

Martinelli, a Java Champion and Oracle ACE Pro, takes a refreshingly honest look at what AI-assisted development actually changes in a senior engineer’s workflow — and what it doesn’t. The core argument: spec-driven development remains the discipline that determines whether AI tools accelerate good engineering or accelerate garbage. The talk shows how defining precise specifications upfront transforms AI into a force multiplier rather than a source of hallucinated boilerplate. For engineering managers, this is the framing you’ve been looking for to have honest conversations about AI adoption without overselling or dismissing it. The “changed everything (and nothing)” title earns its irony.

Loiane Groner delivers a practical, step-by-step integration guide for adding AI capabilities to Angular and Java applications. Rather than staying at the architectural level, the talk gets into API call handling, AI-generated data processing, and real-world UI patterns for surfacing intelligent features. It’s the kind of talk full-stack engineers often can’t find in Java-focused conferences: frontend-aware, concrete, and focused on the integration seams where things actually break. The session makes a strong case that the Java + Angular stack is fully capable of building AI-infused applications without a Python intermediary. For teams maintaining existing Java backends, this is the most direct path to adding AI-powered features.

Mario Fusco provides one of the clearest taxonomies of agentic AI system architectures presented at a Java conference. He distinguishes two categories — workflows (LLMs and tools orchestrated through predefined code paths) and agents (LLMs dynamically directing their own execution) — and shows practical implementations using Quarkus and the LangChain4j extension. The testing section is where this talk earns its place in any engineer’s watchlist: Fusco directly confronts the non-determinism problem and provides strategies for building testable agentic systems in mission-critical scenarios. If you’re evaluating how much autonomy to hand an LLM in your application, this talk gives you the vocabulary and the guardrails to reason about it.

Dan Vega tackles the Model Context Protocol (MCP) — one of the most practically important emerging standards for connecting LLMs to enterprise Java applications. The talk goes from basic setup through building custom MCP servers in Java, with live coding showing how to expose tools and data sources to MCP-compatible AI clients while maintaining enterprise-grade security and control. For engineers who’ve been watching MCP gain adoption in the AI tooling ecosystem and wondering what it means for their Java backend, this is the grounded technical introduction you need. The emphasis on security and data control makes it immediately relevant to regulated industries and enterprise environments.

Jonathan Vila López addresses AI code assistant adoption from the perspective of a practicing Java engineer who wants to use these tools without accumulating technical debt. The central point — “whether you wrote the line or the AI did, you own the code” — cuts through the vibe-coding trend with accountability framing that resonates for any team with serious code quality standards. The talk presents seven concrete habits and the mindset shifts that separate productive AI collaboration from frustrating cycles of accept-and-regret. For engineering managers trying to establish team norms around AI tooling, this is the most direct framework available in the Java community.

This talk covers Project Leyden and the state of ahead-of-time (AOT) caching in Java, demonstrating how to reduce JVM warmup time for real applications. The speakers go beyond theory with concrete examples showing measurable warm-up improvements and a toolkit for optimizing your own application’s AOT profile. For teams running Java in cloud environments where startup latency matters — serverless, scale-to-zero, rapid deployment pipelines — this is a directly applicable technique. The demo effects are presented honestly, including where the approach works best and where it doesn’t.

Bruno Souza presents the Deliberate REPUTATION formula — a structured framework for senior Java developers who want career growth beyond IC work into recognized expertise and community influence. The talk covers open source contribution, community visibility, and the patterns that distinguish engineers who build lasting reputations from those who stay invisible despite deep competence. For engineering managers thinking about retention and growth paths for their senior engineers, this provides a language for conversations about impact beyond the sprint backlog.

Mehmandarov calls out the widespread practice of shipping JSON-RPC over HTTP and calling it REST, then walks through the production-grade patterns that actually make APIs maintainable: evolvable versioning strategies, sane error responses, clear API contracts, and practical HATEOAS usage. The talk demonstrates these patterns using Jakarta EE and MicroProfile with honest coverage of when REST should give way to GraphQL or gRPC. This is battle-tested API design advice delivered without the academic abstraction that often makes these talks hard to apply.

Bazlur Rahman makes the case that Java 25 is a competitive modern language, comparing its capabilities head-to-head with Kotlin, Scala, Rust, and Go. The talk covers virtual threads, structured concurrency, pattern matching, records, and the Foreign Function & Memory API — showing not just what Java can do, but how it stacks up against the alternatives that engineering teams frequently debate. For technical leaders fielding “why not just use X instead?” questions, this provides the concrete feature-level answer.

Oliver Drotbohm challenges the current enthusiasm for hexagonal and onion architectures with a practical question: are these patterns solving the right problem? The talk examines how much abstraction and mapping is genuinely needed between architectural layers, whether persistence metadata in the domain model is actually heresy, and what the real goal of domain-centric design is. Drotbohm uses concrete examples and tooling references to show the trade-offs of different approaches, giving teams a more grounded basis for architectural decisions than most “clean architecture” content provides.

Andrzej Grzesik guides engineers through JVM memory analysis with a focus on practical troubleshooting rather than theoretical GC tuning. The talk covers analysis tools, how to surface what information they expose, and how to trace memory and runtime profile differences back to the code. The framing is deliberately accessible: if you’ve believed memory troubleshooting in Java is “magic” or only fixable by tuning the GC, this talk is the corrective you need.

Falk Sippach covers Project Valhalla’s Value Objects — the most significant change to Java’s type system in decades. The talk explains how value classes combine the performance of primitives with the expressiveness of reference types, covering null-restricted and nullable types, generic typing, and how this changes DDD-style domain modeling in Java. With Brian Goetz’s 2024 announcement that a breakthrough was achieved, this is the right time to understand the conceptual shift. For architects designing domain models, the immutability and identity-free types this introduces will change how expressive performance-critical code can be.

Holly Cummins packages deep Quarkus capability knowledge into a genuinely entertaining format. Beneath the absurd demos — an LLM app designed to hallucinate, a Minecraft observability client, a grapefruit benchmark — is a substantive tour of Quarkus integrations, CLI patterns, guardrails, and extension points. For engineers who learn best from concrete examples rather than abstract architecture diagrams, this is one of the most efficient ways to understand what Quarkus can actually do in production.

Cay Horstmann takes a measured look at Java’s pattern matching evolution from Java 14 through current versions, covering when the data-oriented programming style is genuinely beneficial — and when it isn’t. The talk addresses syntax evolution, upcoming enhancements, and the corner cases where modern switch behavior conflicts with legacy usage. Horstmann closes with actionable rules for when to adopt pattern matching now, how to prepare for future enhancements, and when to stay away. For teams upgrading Java versions, this is the calibrated guidance on this feature set that most conference talks don’t provide.

Richard Fichtner shares 20+ years of hard-earned experience modernizing Java applications with minimal disruption. The talk covers OpenRewrite-based Java version upgrades, migrating Swing to Vaadin for legacy desktop apps, and — crucially — the human factor in modernization projects. The honest treatment of team dynamics, retraining costs, and developer engagement is what elevates this beyond a purely technical migration guide. For engineering managers owning legacy Java systems, the pragmatic sequencing and people-aware approach here is more useful than any “just migrate to the latest version” advice.

Henri Tremblay delivers a live-coded tour of Java 25 LTS covering virtual threads, pattern matching, garbage collector improvements, value types, integrity by default, and AOT. The live-coding format makes the new features immediately tangible rather than abstract. For teams evaluating the Java 25 LTS upgrade timeline, this is the fastest way to understand what’s materially different and what it means for day-to-day Java development.

Mary Grygleski examines how event-driven architectures and multi-agent systems complement each other for generative AI workflows that involve real-time processing and decentralized decision-making. The talk proposes combining event-driven responsiveness with multi-agent collaborative intelligence to build adaptive, scalable AI systems capable of handling complexity that monolithic LLM architectures can’t manage. For architects designing AI-infused business workflow systems, this provides the theoretical foundations alongside practical application patterns.

Eric Deandrea and Oleg Selajev tackle the uncomfortable question every team building AI applications faces: how do you test something non-deterministic? The session demonstrates practical approaches using Testcontainers, LangChain4j, Quarkus, and Ollama for both inner-loop and CI testing of AI-infused applications. The combination of Deandrea’s testing expertise and Selajev’s Testcontainers depth results in a complementary session that addresses the real-world budget and infrastructure constraints teams face when testing with LLMs.

Kenneth Kousen shares four concrete experiments with multi-agent AI orchestration: parallel agents with LangChain4j and Spring AI, coordinating Gemini CLI with Codex CLI and Claude Code, wrapping Gemini in an MCP server, and using a Claude Code sub-agent that delegates to Gemini. The talk is honest about where orchestration pays off and where it gets messy — a refreshing change from most multi-agent content, which tends toward hype. For teams exploring whether to invest in multi-agent architectures, Kousen’s empirical approach provides a realistic baseline.

Tudose and Sonkin introduce JAIG (Java AI-powered Code Generator), an open-source tool designed to replace unpredictable agent improvisation with deterministic, versionable, testable code generation workflows. The “AI Interview” process transforms ambiguous requirements into executable blueprints, and those blueprints drive transparent, reproducible generation. For teams that have been burned by non-deterministic AI agents in their development pipelines, the deterministic workflow paradigm here is the serious engineering alternative.

Barry Burd explains why post-quantum cryptography matters now — not in 2035 when quantum computers become viable. The harvest-now-decrypt-later threat is real: adversaries are collecting encrypted data today hoping to decrypt it once quantum hardware is available. The talk covers Java 24’s two new quantum-resistant algorithms (JEP 496 and JEP 497) — the Module-Lattice-Based Key Encapsulation Mechanism and Digital Signature Algorithm. For security-conscious teams on Java 24+, this is immediately actionable.

Frank Delporte demonstrates how the Foreign Function & Memory (FFM) API finalized in Java 22 transforms hardware integration for the Pi4J project. The talk shows how FFM replaces complex JNI/JNA code with cleaner, higher-performance native integration, demonstrated via live demos controlling LEDs, buttons, LCD displays, and sensors. For Java developers interested in IoT and embedded systems, this makes hardware interaction more accessible than any previous Java API.

Kito Mann presents a real-world modernization project using OpenRewrite combined with deep expertise in Spring and Jakarta EE. The talk is grounded in actual migration experience rather than theoretical frameworks, covering how automated code transformation handles the mechanical parts of modernization while human expertise handles the architectural decisions. The security framing — older library versions carry real vulnerabilities — makes the business case for modernization concrete rather than aspirational.

Elias Nogueira addresses the testing pitfalls endemic to distributed systems: in-memory databases that mask production behavior, brittle mocks, and flaky async tests. The talk proposes five strategies for a real-world fintech architecture — using real dependencies, avoiding in-memory databases, virtualizing external systems, testing async flows properly, and enforcing API governance. For teams whose test pipelines provide false confidence on complex microservice architectures, this is a direct remediation guide.

Patrick Baumgartner covers Cloud Native Buildpacks architecture in depth: how the lifecycle component manages source-to-OCI-image conversion, the detection and export stages, and how Paketo Buildpacks simplify configuration. The real-world examples of organizations using Buildpacks to streamline CI/CD pipelines make this more than an architecture overview. For platform engineers managing Java container image builds at scale, the rebasing and reproducibility features here address real operational pain points.

Tom Cools uses an accessible vehicle routing scenario — Santa’s delivery route — to demonstrate Timefold, an open-source AI solver for constraint satisfaction and optimization problems. The talk shows how domain classes, constraints, and solver configuration come together to tackle routing problems without requiring deep operations research expertise. For Java engineers encountering vehicle routing, scheduling, or resource allocation problems in enterprise systems, this opens a practical tooling path that doesn’t require a PhD in combinatorial optimization.

For engineering managers: the skills to invest in are LLM integration patterns in Java, Java 25 feature adoption, and the discipline of spec-driven or test-driven development as a forcing function for AI-assisted coding quality.

You’re reading Talk::Overflow #26 — the weekly digest for developers who want to stay sharp and skip the noise.
→ Browse past issues
→ Suggest a talk
→ Share it with the friends

Stay curious. Stay kind.

— Talk::Overflow