Conference Sessions

Java has changed faster in the last few years than it ever has before. Moving from Java 21 to Java 25 brings meaningful improvements across the language, runtime, and developer experience. This session walks through the changes that matter in real projects. We’ll look at the refinements in pattern matching, records, and unnamed patterns, explore how virtual threads and structured concurrency reshape server-side design, and see the first practical impact of Project Valhalla’s primitive classes. We’ll also cover developer-friendly additions like Compact Source Files and instance main methods, which make Java lighter and easier to use for scripting and quick utilities. Along the way, we’ll highlight updates to the Foreign Function & Memory API and the JVM performance gains that arrive in the latest release. By the end, you’ll have a clear picture of what modern Java looks like today and how to adopt these features confidently.

Now that LLMs dominate headlines, what is the Java developer’s role? An LLM is an ocean of knowledge with occasional illusions. It does not know your business rules, policies, or transaction semantics. If you want it to help real accountants or domain experts, you must supply your context and the reasoning over that context. That is context engineering.

Just as an RDBMS holds application metadata, LLM applications need two additional stores. A Graph DB captures relationships and policy scope: parent, sibling, neighbor, depth. A Vector DB holds domain documents and records for semantic retrieval. For any goal, you assemble the right facts and the reasoning path, then feed both to the model.

In this session we build a thin Context ORM in Java that can parse domain documents, index entities and relationships into a Graph DB, embed documents and records into a Vector DB, and provide a retrieval mechanism that stitches the right context and reasoning into prompts. We use Spring AI, DuckDB with vector search, and a small business domain with dummy data. You will see how to ground answers in your rules, test them, audit them, and make LLM output reliable for real work.

Resilience Engineering in Java systems focuses on building applications that continue to function even when parts of the system fail. It emphasizes designing for failure from the start rather than reacting after problems occur. Java developers use key resilience patterns—such as retries, exponential backoff, fallbacks, rate limiting, bulkheads, and circuit breakers—to ensure systems remain stable under stress. Tools like Resilience4j, Spring Cloud, and MicroProfile Fault Tolerance make it easier to apply these patterns in production.

Modern distributed systems face challenges like network latency, partial outages, and dependency failures, making resilience essential in microservice architectures. Circuit breakers help isolate failing components, preventing cascading failures. Bulkheads create boundaries between services so that one heavy workload doesn’t overload the entire system. Timeouts and rate limiting protect resources from being overwhelmed during traffic spikes or malicious requests.

Observability—metrics, logs, and distributed tracing—is also a critical part of resilience engineering, enabling teams to detect failures early and respond quickly. Chaos engineering practices validate resilience by intentionally injecting failures to observe system behavior. Overall, resilience engineering ensures Java applications remain reliable, responsive, and fault-tolerant, even in unpredictable real-world conditions.

For Java developers, the GenAI landscape is shifting rapidly. One day it’s all about RAG, the next it’s about Agents. But when you move from prototype to production, which pattern actually holds up?

Join this session for a deep dive into the architecture of LLM integration. I will break down the three primary patterns—Retrieval-Augmented Generation (RAG), Agents, and Fine-tuning—and evaluate them strictly through the lens of a Java engineer. I’ll cut through the hype to discuss system boundaries, latency issues, and the real cost of operations. Whether you are modernizing a legacy monolith or building cloud-native microservices, this talk will give you the blueprints you need to make the right architectural call.

This lecture explores the significant role of the Java programming language in modern academic research, highlighting its strengths in portability, performance, and ecosystem richness. It discusses how Java supports diverse research domains including optimization, simulation, machine learning, big data analytics, and scientific computing. Key libraries, frameworks, and tools are reviewed to demonstrate how Java enables fast prototyping, reproducible experiments, and scalable computational studies. The talk also emphasizes best practices for writing research-grade Java code, from experiment management to benchmarking and documentation. Overall, the lecture positions Java as a versatile, reliable, and powerful language for conducting rigorous and impactful academic research.

In this talk, I share my decade-long journey through the evolving world of DevOps and platform engineering—an experience shaped by curiosity, continuous learning, and a commitment to building systems that scale. Starting as a Linux enthusiast, I gradually transitioned into modern DevOps practices, mastering automation, infrastructure-as-code, and cloud-native architectures. Over the years, I have had the opportunity to design and lead the implementation of enterprise-grade Kubernetes platforms, containerized application ecosystems, and high-availability database clusters that support mission-critical workloads.

Throughout my career, I have worked closely with cross-functional teams to break operational silos, streamline development pipelines, and introduce DevSecOps principles across organizations. My roles—as a DevOps Engineer, Principal DevOps Architect, and now Head of Platform Architecture and DevOps Engineering—have enabled me to blend strategy with hands-on expertise. This includes enabling CI/CD adoption, leading cost-optimization initiatives, setting up observability stacks, and mentoring engineers to build strong platform mindsets.

As a Red Hat Certified Architect and Kubernetes specialist, I have focused on simplifying complex infrastructure problems while ensuring security, resilience, and operational excellence. This talk aims to highlight key lessons from building platforms from scratch, overcoming organizational and technical barriers, and navigating the human side of DevOps transformation.

Attendees will gain insights into practical strategies, leadership experiences, and technical patterns that can help them accelerate their own DevOps journey—whether they are just starting out or scaling their platform engineering capabilities.

Working with legacy code often feels like navigating a minefield—every change carries uncertainty, hidden dependencies, and the fear of breaking something that once worked. It’s slow, frustrating, and sometimes exhausting. Yet refactoring is the only way to restore clarity, bring structure back into the system, and make the codebase future-proof.

This session will walk you through practical techniques for identifying few code smells, reducing technical debt, and modernizing old structures without breaking what already works. The goal is simple: turn chaos of legacy code into clean, readable, testable and maintainable codebase that supports faster development, fewer bugs, and long-term stability.

Modern Java development often feels like sticking LEGO blocks together without understanding how they fit. We rely so heavily on frameworks like Spring that we forget the power of the language itself.

It’s time to discard the crutches. With the JDK more powerful than ever, do we really need all that extra weight? This talk is about building robust, production-ready software using nothing but standard Java. We will trade “magic” abstractions for discipline and design patterns. By the end of this session, you’ll see that you don’t need a long dependency tree to build good software—you just need to master your language. Let’s get back to basics and see what Java can really do.