JavaOne 2026 Sessions

Looking to learn about features in the language added after Java 21 in more detail? As programmers, we're used to dealing with edge cases. But what about edge cases in the language?

As certification book authors, we encounter lots of interesting and/or surprising behavior. After a brief overview of the cert, we'll explain these features and walk through tricky questions featuring functionality added to the language from Java 17 to Java 25. Plus there'll be coding practice to explore the new features.

Walk away with an increased awareness of these Java topics.

The Loom project is to make asynchronous programming simpler, enabling the "simple thread-per-request style to scale with near-optimal hardware utilization". Before virtual threads, this was only achievable with callback-based reactive programming.

In this lab, we'll guide you through writing a virtual thread-based web application that uses structured concurrency to parallelize requests, and implements different strategies to process them. Then you'll see how to use scoped values to pass sensitive info from one module of your application to another one, without relying on method parameters.

See the patterns of code the Loom project gives you to achieve the same throughput as a classical reactive application. You can then compare the code patterns of both approaches to choose which you prefer.

Data-Oriented Programming is a programming model paradigm, alternative to Object Oriented Programming, that allows you to organize your application code differently. Its goal is the same as Object Oriented Programming: enabling the extension of a given object model by adding new types and new behavior. Since Java is an Object Oriented language, it uses tools already there such as records, sealed types (mostly interfaces), exhaustive switch expressions, and pattern matching.

This hands-on lab gives you a simple application as a starting point and uses a step by step approach to guide you through a Data-Oriented Programming refactoring. Once this refactoring is done, it shows you how to add new types and behavior so you can compare with the Object Oriented approach. By the end of this workshop, you'll have a better understanding of Data-Oriented Programming and how and where you can apply its principles in your application.

For over 30 years, Java has profoundly shaped the world we live in. From every use-case imaginable, Java powers applications that deliver business value. And, as the pace of technology keeps increasing, Java continues to thoughtfully evolve to meet the needs of modern application development.

In this keynote, learn how Java is addressing the emerging world of AI while retaining its virtues of providing enterprise-grade performance, stability, and security.

Community has been a core pillar of Java’s success for more than three decades. The vibrancy and passion of the Java community results in active participation, accelerating innovation, learning, and collaboration. From OpenJDK, to the Java User Group program and the many connections in-between, it’s your engagement that's been the heartbeat of Java.

This keynote is about YOU, and through inspiring examples, showcases how together we can keep Java moving forward for the next three decades.

JavaOne offers you the unique opportunity to connect with Java architects from Oracle. The “Ask the Architect” keynote affords YOU the opportunity to bring in-depth technical questions and have them addressed by Oracle’s Java experts.

Valhalla updates? Java language enhancements? Where is Java going in AI? Status of AOT? In this lively in-person Q&A, get your inquiries answered and leave more inspired about the future of Java.

Java offers developers a vast suite of cryptographic tools. Using these tools requires expertise and can often be daunting and scary. This talk discusses approaches for teams to use Java Cryptography in ways that are safe, compatible, and forward-looking. Topics will include encryption, TLS, certificates, key stores, policy, and upgrading.

The Stream API provides a wealth of methods, such as filter, map, takeWhile, limit, and more, to build functional pipelines. But you may encounter situations in your applications that don't readily lend themselves to these built-in methods. The new gatherer() function, along with the Gatherer interface, gives you the necessary tools to create your own custom steps in the functional pipeline.

In this presentation, learn about the different types of gatherers and how to implement them using practical live-coded examples.

Java doesn’t have compile-time null safety, so developers can still use null freely, often leading to the infamous NullPointerException and painful production bugs. Null safety in Java is more than defensive coding, it’s the story of how the language, APIs, and tools have evolved to represent “no value” more clearly.

This talk explores the past, present, and future of null safety in Java, from null checks, the Null Object pattern, annotations, and Objects.requireNonNull to newer features like pattern matching, switch guards, and design choices such as using empty collections instead of null.

Come see how Optional made APIs more declarative and expressive, especially in Streams. We’ll also look at how JSpecify and Project Valhalla are advancing null safety and how static analyzers can help. You’ll leave knowing how to write modern, null-safe Java using the right patterns, tools, and language features to keep NullPointerExceptions out of your code.

Are you struggling with multithreaded Java code that just won't behave You aren't alone, and sometimes it can feel downright frustrating. But here's the twist: Java is arguably one of the most deterministic programming languages out there. Of course, diving into the Java Memory Model specification isn't exactly a light read. The good news? This session will share a practical trick with you. Let's unravel the mysteries of Java concurrency together.

Collections are easy to use in practice. At least, that’s what you'd think after reading most tutorials on the subject. But real life isn’t always so straightforward. You need to apply object design principles intelligently if you want to use collections in a large system without running into trouble.

In this talk, we’ll look at some common system design errors involving collections, and for each one, we’ll figure out a better way. For example, we’ll show how extending the idea of encapsulation to collections leads to thinking about ownership of data and how to safeguard it, allowing you to avoid many problems by using some simple rules. Other topics will include other ways of applying object design principles when a collection doesn’t have exactly the functionality needed.

You’ll leave this presentation with a wider perspective on object-oriented design, and with an understanding of how to detect and eliminate design smells in your system’s use of collections.

Learn how Netflix used Project Leyden to improve startup time of critical services and the software and SDLC we built to make that happen.

The Foreign Function & Memory API (FFM) was finalized in JDK 22 and has undergone several performance improvements. JDK 25 is the first LTS release to include the FFM API. In this talk, we'll learn how this allows us to avoid the previously slow, brittle, and complex process of using JNI and ByteBuffers. Instead, we can manage native memory and link native libraries directly from our favorite programming language, Java.

Join us for a deep dive with live coding showing how to specify, allocate, and work with native memory and how to link and call native functions. We'll also demo how to use the automatic binding generator tool "jextract" to effortlessly generate Java bindings to the ONNX Runtime, the open standard for machine learning models.

Whether you're an architect rethinking cross-platform integration or eager to conduct AI inference in Java, this talk is for you. Finally, we can say hello to high-performance native Java integration and wave goodbye to JNI.

The Java programming language is evolving fast. In this talk, we’ll summarize many of the recent changes that have appeared as well as look ahead to directions and features that are in development and will appear in future editions.

Just-in-time (JIT) compilation within the JVM is essential to Java's performance and plays a central role in ongoing OpenJDK projects such as Valhalla, Leyden, and Panama. JIT compilation is constantly evolving to support the evolution of the Java language, its main application areas, deployment models, and underlying hardware.

This talk provides an overview of recent performance improvements delivered by the JVM's JIT compilers, both as part of and in addition to OpenJDK projects, and highlights some of the most significant ongoing developments in this area.

Since JavaOne 2025, JDK 25 was released, the latest version with long-term support. But Java never stands still; it's already time to ship JDK 26. This talk summarizes the most important changes between Java 21 and 25:

• from unnamed patterns and flexible constructors to module imports
• from the foreign-function and memory API to stream gatherers and the class-file API
• from a simpler `main` to launching multisource-file programs
• from Markdown in JavaDoc to quantum-resistant encryption
• from faster launch times to improved garbage collection

... before taking a closer look at the newest release, including its preview features:

• Primitive patterns and lazy constants
• Updated structured concurrency
• PEM encoding and HTTP/3 support
• New command-line options to enable deep reflection

There are plenty of features in the language, API, and runtime to discuss; whether new, improved, or finalized. Let's go over them.

Since the original release in 1995, the Java platform has supported `float` and 'double` floating-point types, and the`java.math` package added in JDK 1.1 included `BigDecimal` and `BigInteger` as library types. Together with other library changes along the way, the set of numeric types in the Java platform has been stable many years.

Scientific and engineering computation relies on linear algebra and complex numbers, while machine learning benefits from computing on smaller numeric types including 16-bit floating-point numbers and with *8-bit* floating-point formats for machine learning under consideration for standardization.

This talk will discuss ways to provide full support for new numeric types in the Java platform.

Today, the security of the world's digital infrastructure relies on traditional public-key based cryptographic algorithms such as RSA, and Diffie-Hellman and its elliptic curve variants. However, there's a looming threat on the horizon predicted to eventually break these algorithms: quantum computers.

In this session, we'll show how the Java Platform is preparing for this paradigm shift in security by adding support for Post-Quantum Cryptography (PQC), which are algorithms designed to be secure against quantum computer attacks. Come to this session to learn about the PQC-related features we've already delivered and what we're working on for JDK 27 and beyond.

It's 2 AM Friday night when you get alerts your primary business application stopped responding and user tickets are piling up. For situations like these, you need to have already captured the data that can help you quickly get a sense of what's going wrong. Yet many production environments don't have such data collection enabled, and some diagnostics have performance costs that are unsuitable for many production applications.

In this session, we’ll use some commonly reported Java heap memory problems to show how to collect and analyze some low-cost data to diagnose those problems at first-time failure.

Throughout the project, Vector API balanced providing cross-platform API while staying close to the metal performance-wise. The project succeeded at that goal, yet Vector API had to give up on some functionality that didn't fit the design. As a result, the API became unsuitable for implementing an important class of vectorized algorithms. With recent progress in Project Panama (on Foreign Function & Memory API and jextract), there are new opportunities emerging to bring Java even closer to hardware.

This talk covers how Vector API evolved and features success stories while pointing out cases where it fell short. The focus then shifts towards interactions with other APIs and tools (in particular, Foreign Function & Memory API and jextract). Lastly, future opportunities being explored in Project Panama and Project Babylon are covered (such as auto-vectorization through code reflection, vector calling convention support in FFM API, and hardware intrinsics in the JVM).

We'll review new and upcoming Java features that improve the convenience, reliability, and performance of immutable data, including:

• Records, record patterns, and derived record creation
• Value classes and objects
• Early field initialization with flexible constructor bodies
• The lazy constants API
• Initialization diagnostics for static final fields
• Unsafe reflective mutation or deserialization and the marshalling API as an alternative
• In the future: immutable arrays?

We'll discuss how these features complement each other, what sorts of JVM optimizations they enable, and how to decide when they're a good fit for an application.

Memory-related issues remain a common challenge in Java-based applications, leading to heap exhaustion, performance degradation, and even system failures. Out-of-memory errors are particularly devastating, causing costly downtime.

This session aims to uncover the diagnostic tools and troubleshooting techniques to tackle these issues. We’ll discuss how to collect and analyze different forms of diagnostic data, including heap dumps, GC logs, NMT output, as well as other critical troubleshooting information. We’ll then explore how AI-powered agents, built with LangChain4j, can revolutionize JVM memory troubleshooting. Discover how these agents can rapidly analyze diagnostic data, correlate errors, and suggest actionable steps to resolve issues faster. Concrete examples will show how AI can assist in quickly pinpointing memory issues, reducing downtime, and enhancing performance.

Join us to dive into strategies to troubleshoot memory problems in Java applications.

Whether new to Java, returning after a break, or looking to modernize an existing approach, this session helps participants navigate the vibrant Java ecosystem of 2026 with confidence. Beyond the language itself, the Java ecosystem continues to expand with powerful build and testing tools, modern frameworks, deployment platforms, and performance-tuned runtimes.

Drawing on practical experience from diverse teams and projects, the session highlights the technologies and practices that make the greatest impact in day-to-day development. Attendees gain actionable insights into modernizing their stack, improving developer productivity, and making informed technology choices, all while staying aligned with emerging trends like AI integration, cloud-native development, and sustainable computing.

Agentic coding assistants and editor based AI chat interfaces are altering the development workflow, leading some to proclaim the end of software engineering. Is it time to explore other careers? Not so fast, The rumors of our demise are greatly exaggerated. These tools can boost productivity, but to be used effectively, developers still need to master the fundamentals of the software craft. Modern software development demands more than just coding proficiency, it requires navigating an increasingly AI-augmented landscape.

For years, developers have argued that Java is “too complex” for beginners, but is it? Over the past three years, we’ve run a free bootcamp, the last one for people in a few countries of Latin America, teaching programming using Java as their very first language.

This talk shares the insights, surprises, and data gathered from teaching more than 200 students. Whether you mentor developers or simply care about Java’s future generation, this session offers a grounded perspective on why Java is a great choice for a first programming language.

AI agents are advancing, but the performance and scalability—both for the agents and their supporting services—often lag behind. In this lab, you'll:

• Build scalable services with Helidon using Virtual Thread–based MCP servers
• Implement high-performance agents via Helidon’s compile-time integration with LangChain4j
• Deploy to a cloud-native platform (e.g. Kubernetes)
• Instrument and observe performance with OpenTelemetry and Prometheus

Who should attend:

• Java developers and architects exploring AI agent frameworks
• Platform and SRE engineers focused on performance, scalability, &observability
• Teams evaluating AI, LangChain4j, and microservices in a cloud native environment

Leave with a production-ready pattern for building and observing scalable AI agents and services with Helidon, Virtual Threads, LangChain4j, Kubernetes, and OpenTelemetry, complete with instrumentation and deployment practices aligned to cloud-native operations.

See how Oracle Code Assist (OCA) and Cline—an open-source, collaborative agent framework—can streamline building modern Helidon applications.

What you’ll learn:

• Install and configure Cline to work with OCA in your IDE
• Select and manage AI models via OCA
• Use Cline as a coding assistant to create Helidon applications
• Apply new Helidon features: Helidon Declarative, Helidon Data, and Helidon MCP
• Use OCA and Cline in team workflows for collaborative development

Who should attend:

• Java developers building microservices
• Teams adopting AI-assisted development in enterprise environments
• Tech leads and architects evaluating AI pair-programming workflows

By the end of this lab, you'll have a working Helidon application built with AI-assisted workflows, practical experience selecting models via OCA, and a repeatable approach to using Cline for individual and team development, including new Helidon features.

As AI rapidly evolves from model experimentation to production-grade applications, Java developers are increasingly faced with a new paradigm: designing intelligent systems that can reason, interact, and adapt.

This talk explores the emerging Java AI application development journey through the lens of agent-based architecture, with a focus on how the Model Context Protocol (MCP) and Agent2Agent (A2A) communication patterns are transforming the way we build intelligent, context-aware services.

We’ll walk through the foundational shifts in building AI-native Java applications—moving beyond single-shot prompt-response interactions to multiagent coordination, persistent memory, and tool-augmented reasoning. We’ll also address the critical architectural trade-offs: performance versus flexibility, open source versus vendor-managed inference, local versus remote model deployment, and how to maintain security and observability in agent-based systems.

As developers, we’re increasingly using AI and large language models (LLMs) in our apps. But there’s a growing concern we need to stay on top of: prompt injection. This sneaky attack can mess with our AI systems by manipulating the input to get unexpected results.

This session breaks down what prompt injection is and look at some common tricks attackers use, like instruction overrides and hidden prompts. The session also goes deeper into more advanced challenges, including escalation techniques that can make these risks worse. Most importantly, the session won’t just talk about the problem, it shares practical steps you can take to protect your AI systems and keep things secure. Attend to learn how to stay ahead in AI security and make sure your apps are resilient against these emerging threats.

GenAI is not another Java library you can drop into a project and forget about. You can't just add a dependency, pick Java 25 as your JDK, and expect reliable, production-grade results. Because GenAI is non-deterministic, it can produce outputs that surprise you and pose a significant risk if you don't know how to manage it. At the same time, AI is now influencing products, teams, and even entire economies. Java developers need to understand it, not watch from the sidelines.

This session is for Java developers who want to build GenAI features in real Java, using Java 25 and LangChain4j, a well-designed framework for working with LLMs from Java. You'll see working code for context handling, smarter prompts, RAG, chatbot design, ingestion, streaming, Tools, and Agents. We'll also highlight the significant risks posed by GenAI. You'll leave knowing how to make a Java chatbot that actually knows about Java 25.

Java developers face a critical challenge: how do you securely and efficiently connect these AI models with enterprise data and tools? The Model Context Protocol (MCP) is transforming how AI applications interact with external systems, and it's rapidly becoming an industry standard.

In this session, you'll learn the basic building blocks of MCP and how to build, secure, and test your MCP servers. Through practical examples, you'll gain everything you need to build and deploy your own MCP servers. This session is perfect for Java developers ready to give their applications AI superpowers.

As AI becomes central to enterprise innovation, developers face the challenge of integrating it into large-scale Java systems without losing performance, scalability, or security. New Java features such as the Foreign Function & Memory (FFM) API and Vector API unlock GPU acceleration and new performance frontiers for AI workloads. These innovations enable optimized, portable, and maintainable AI pipelines fully in Java, with seamless CPU/GPU execution.

This session demonstrates how to build Java-native AI using modern libraries and benchmarks showing performance on par with industry standards, while improving operational efficiency, maintainability, and security. Attendees will see how frameworks like Deep Netts combine deep learning capabilities with the robustness of the JVM to build, train, and deploy neural networks directly in Java, eliminating the need for Python bridges and simplifying enterprise AI integration.

You can code with an LLM and never think about what goes on inside the LLM. But once you peek inside, the inner workings lead to new insights, and new ideas begin to spark. This talk explores how data flows, how weights and biases shape learning, and how layers transform simple inputs into useful predictions.

We’ll demystify neural nets using clear, visual diagrams and walk through working examples written in Java. Why would you use Java to create a neural net? Rod Johnson says, “Too many people assume Gen AI means Python. Not so.” Java is versatile, readable, and just plain fun. Java is perfect for powering the next generation of production-ready AI systems. You’ll leave this session with a deeper understanding of the workings of neural nets and a new appreciation for Java as a tool for AI.

The more you know about AI and its relationship with Java, the more equipped you are to use AI effectively.

Enterprise and government document systems hold terabytes of valuable unstructured information, yet most still rely on keyword and metadata search with little semantic context. Retrieval-Augmented Generation (RAG) promises a breakthrough, but tutorials rarely prepare you for regulated, large-scale environments.

In this talk, we'll share lessons from building a RAG stack with Spring Boot, Elasticsearch, LangChain4j, Docker, and ActiveMQ, using both Azure OpenAI and Ollama. Expect concrete insights on document chunking, enforcing access control, and keeping LLMs grounded in facts, all practical takeaways for anyone bringing RAG from demo to production.

The Dataverse is an open source Java EE application for preserving, sharing, and replicating research data in accordance with the FAIR (Findable, Accessible, Interoperable and Reusable) data principles. Rich metadata and persistent identifiers allow datasets to be shared and integrated with other datasets. Occasionally, the data archiving workflow misses the mark because the data creator doesn't provide crucial metadata such as the Subject category of the data set.

This session demonstrates a method to generate Subject recommendations based on the Subjects of existing datasets with similar descriptions. This method uses LLM embeddings of dataset descriptions stored in a Neo4J knowledge graph.

Heterogenous Accelerator Toolkit (HAT) is a novel parallel programming framework designed to accelerate Java parallel workloads on heterogeneous hardware, including Graphics Processing Units (GPUs). HAT leverages the code-reflection APIs introduced in the OpenJDK project Babylon to tackle code transformation that helps developers translate sections of the Java programs to foreign programming languages, such as CUDA and OpenCL. HAT also provides a runtime system to automatically manage the generated code, data handling, and data migration automatically.

In this talk, we'll discuss the core components of the HAT API and show using examples how Java developers can offload data-parallel workloads to GPUs to achieve significant performance improvements.

While AI agents are rapidly advancing, the performance and scalability of the agents and their underlying services have received too little attention.

In this session, we showcase Helidon powering scalable services via Virtual Thread–based MCP servers and high-performance agents through its compile-time integration with LangChain4j. We then deploy them to a cloud-native platform like Kubernetes and use OpenTelemetry for monitoring and tracing.

In the rapidly expanding AI landscape, agentic systems need reliable event orchestration, exactly-once delivery, and frictionless access to application data.

In this session, you’ll learn how Oracle AI Database and Transactional Event Queues (TxEventQ) make this easy using the Kafka Clients Java API—no Kafka cluster required. We’ll build event-driven agent workflows directly from a Java app, covering semantic routing with rule-based subscribers and vector search integration. You’ll learn how transactional messaging lets agents produce, consume, and update data automatically.

By the end, Java developers will understand how to unify streaming and database operations to build resilient, intelligent, multiagent systems.

Project Babylon continues to simplify access to foreign programming models through the development of code reflection. Using code reflection, a Java program can be lowered into a symbolic form then translated into foreign models such as CUDA and OpenCL, allowing programs to be executed on different platforms.

In this session, we'll introduce Project Babylon and examine how it's used by HAT (Heterogeneous Accelerator Toolkit) to make GPU programming more approachable for Java developers. We'll focus on new HAT features that leverage code reflection to create layers of abstraction and cleaner translations between Java and performant GPU code.

How do you monitor your JVM applications effectively? A powerful option is JDK Flight Recorder (JFR). JFR simplifies troubleshooting and profiling by capturing detailed JVM events, and its streaming API lets you access them in real-time. But what if we could stream live JFR data directly into an AI system to enhance monitoring or even prevent potential issues before they occur?

This session shows how to use JFR to build self-improving applications with AI and new JDK features. Using a real-life simulated example, you’ll learn to stream JFR data, integrate JVM events with AI, spot performance bottlenecks and unusual behavior automatically, and build better debugging and monitoring tools.

By the end, you’ll have a roadmap for combining JFR and AI to enhance troubleshooting and observability.

Build a voice assistant in Java that feels fast, fair, and fail‑safe. We'll explore at a high level AI services available in OCI and walk through core AI concepts behind real‑time conversational systems. Then we'll apply modern Java (JDK 25) patterns to keep latency low, add guardrails for turn‑taking and graceful escalation, and define how to evaluate quality beyond speed.

This is a practical, intermediate‑friendly session focused on patterns you can reuse, with enough depth to help you ship confidently—no deep dive into domain specifics required.

We'll discuss how Java is already a good fit for AI and how it can fit better with existing and future features of the Java platform. Such features vary across the whole Java platform, from the language, libraries, and runtime. Some are associated with OpenJDK projects, such as Projects Amber, Babylon, Valhalla and Panama. Some are more modest in scope and yet in combination have a larger impact.

Imagine building AI models like LLMs and image classifiers directly in Java and running them efficiently on your GPU. Project Babylon introduces the experimental Code Reflection technology that lets you express machine-learning logic in plain Java, without Python or external model files.

It uses FFM to link your code to native runtimes like ONNX Runtime for fast inference and GPU acceleration. For broader parallel workloads, Babylon’s Heterogeneous Accelerator Toolkit (HAT) offers a programming model for writing and dispatching compute kernels, enabling Java libraries to tap GPU power for high-performance parallel computing.

In this session, we’ll explore Babylon’s upcoming features and how they connect Java with modern AI workloads.

The Open Neural Network Exchange (ONNX) provides a standardized format for machine learning models, enabling seamless deployment across various platforms and systems.

While Large Language Models (LLMs) are typically built in Python with frameworks such as PyTorch or TensorFlow before being exported to ONNX for inference, this session challenges that norm by showcasing Java's potential in AI model creation.

Discover how to generate ONNX models directly in Java, a language rarely linked to AI development, using Project Babylon's innovative code reflection features.

Through a practical example, we'll build a generative AI LLM in Java, walk through its conversion to ONNX format, and demonstrate efficient execution, bridging the gap between Java ecosystem and cutting edge AI workflow.

This presentation provides a comprehensive overview of virtual threads, a modern concurrency feature in Java.

It begins by introducing virtual threads and their benefits, followed by a comparison with traditional threading models. The session identifies scenarios where virtual threads are the preferred choice and where their use may not be appropriate.

We'll go through the common issues that can arise when adopting virtual threads and offer practical strategies for diagnosing such problems. The presentation explains which diagnostic data to collect, how to interpret it, and includes real-world examples for hands-on understanding.

Finally, it summarizes best practices to guide developers in effectively leveraging virtual threads for robust and efficient application development.

Artificial intelligence is advancing well beyond simple chat interfaces. Modern Java applications can now incorporate Retrieval-Augmented Generation (RAG) to provide grounded, verifiable responses, and the emerging Model Context Protocol (MCP) to enable secure and controlled access to tools and data.

This session shows how generative AI can be integrated into Java systems using open-source libraries, embeddings, vector databases, and orchestration layers. We'll walk through a practical progression starting with a basic chat, extending it with RAG using domain knowledge, and finally enabling safe external actions through MCP. We'll also explore architectural patterns, integration strategies, and key considerations for performance, deployment, and safety.

Attendees will learn how to incrementally adopt AI within existing Java applications to deliver more helpful, transparent, and capable features.

Projects often use the Java Persistence API (JPA) by default, and thus mostly Hibernate. But do all applications need a comprehensive object-relational mapping (ORM) with every conceivable function?

This talk discusses the architecture of database-centric applications and discusses whether you always need an object graph for persistence. Using an example application, it's shown how pure SQL, with the help of jOOQ and (nested) Java Records, simplifies data access and how common ORM problems such as the n+1 select problem can be avoided.

Finally, the possibility of combining jOOQ with JPA/Hibernate to leverage the best of both worlds is discussed.

At CERN, Java has been at the core of business applications for almost three decades, with its first production Java system being released in 1998. The system lives on to this day. This long history means dealing with everything from aging monoliths to modern microservices, all coexisting and evolving under one roof. How does it all keep working, consistent, and productive for more than 80 developers across many teams?

This talk analyzes the strategies used to streamline & improve the developer experience: from standardizing development environments with templates and documentation to making onboarding painless through easy bootstrapping.

You'll also hear how CERN uses Gradle to boost productivity, with centralized build logic, build caching, custom repositories, and internal plugins all developed to address real-world issues in a codebase spanning generations. This talk offers a behind-the-scenes look at what it takes to keep 30 years of Java running smoothly.

This is the 2026 update of How Netflix Uses Java. In this session, you’ll see how Java powers your favorite Netflix shows and take away practical lessons for leveraging Java more effectively in your own organization. The Netflix architecture and the way we use Java is always changing.

On top of that, Java itself and the OSS ecosystem are evolving faster than ever. Come learn how Netflix is using Java in 2026 and what benefits and challenges we’re seeing running most of our services on the latest Java releases. We’ll explore how we build services with Spring Boot, DGS/GraphQL, and gRPC, and how we manage dependencies to keep more than 3,000 Java services consistently updated across frameworks, libraries, and JDK versions. You’ll hear our experiences with new runtime features such as generational ZGC, Virtual Threads, and AOT for faster startup. Finally, we’ll look at how Java plays a critical role in leveraging AI in our services.

Thanks to its open ecosystem of specifications, source code, JSRs, JEPs, mailing lists, MicroProfile, and Jakarta EE, Java was the perfect training ground for LLMs. These models learned not only syntax, but Java's patterns, idioms and design philosophy.

Through live coding, we'll show how to leverage this knowledge using short prompts and rapid iterations. We'll cover:

• Engineering prompts that adhere to Java conventions and best practices
• Using agents for autonomous code generation and refactoring
• Maintaining architectural consistency with Spec-Driven Development
  
• Incremental code improvement with agents
  
• Sharing best practices through instructions, rules, and steering files
• Developing "Prompt Specific Language" (PSL) for consistent code generation

We'll also generate idiomatic Java 25 code that's both machine-readable and human-friendly. Questions and discussion are encouraged throughout.

Spring Boot 4.x and Java 25 have arrived, making it an exciting time to be a Java developer. Join us as we dive into the future of Spring Boot with Java 25. You'll learn how to scale your applications and codebases effortlessly, explore the robust Spring Boot ecosystem featuring AI, modularity, seamless data access, security, and cutting-edge production optimizations like Project Loom's virtual threads, GraalVM, AppCDS, and more.

Come explore the latest-and-greatest in Spring Boot to build faster, more scalable, more efficient, more modular, more secure, and more intelligent systems and services.

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 maintainable and scalable APIs. 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.

Most Java teams carry more technical debt than they realize. Moving from JDK 8 or 11 to JDK 21 or 25 isn't a simple upgrade, it's a shift across a decade of removals, encapsulation, JPMS changes, GC updates, and performance improvements that reshape how you deploy software.

This talk gives developers & architects a direct look at what modernizing a large Java fleet involves. What breaks, why it breaks, how to diagnose issues, and how to build a repeatable migration path without risking the platform or the budget.

The session includes:

• Using JDK tooling (jdeps, jdeprscan, runtime flags) to find hidden technical debt
• Internal API removals, split-package problems, and reflection failures
• Practical migration strategies
• How JPMS affects legacy code
• The support landscape
• Why JDK 25 is a stable long-term target

If you run real Java systems, this session gives you the map, the risks, and the safe route forward.

Understanding how to monitor and optimize Java applications is fundamental to building efficient software.

This hands-on lab will introduce how to capture data to understand your application behavior using JDK Flight Recorder (JFR), manage and analyze JFR recordings, and guide you through creating custom JFR events. We'll also cover how JFR can integrate with Prometheus to correlate application and infrastructure behavior, all aimed at enhancing observability.

After this lab, you'll have the confidence to use JFR to monitor, diagnose, and fine-tune your applications.

AI coding agents are powerful, but often unpredictable. They jump into implementation, miss requirements, or produce code that can't be tracked. Spec-driven development brings structure and control to this process. The method is simple: start with clear, high-level requirements, refine them into a detailed development plan, then break that plan into a task list with trackable steps. The AI agent works from these artifacts—requirements.md, plan.md, and tasks.md—instead of ad-hoc prompts. Each step becomes explicit, reviewable, and repeatable.

In this talk, we'll show how to apply spec-driven development through a practical example—defining requirements, generating a plan, creating tasks, and guiding the AI step by step. You’ll learn techniques for keeping AI workflows structured, auditable, and reliable. If AI coding feels chaotic, this session offers a framework for turning it into a dependable partner.

Defining and measuring quality across diverse agent platforms is essential as the line between developer-written code and agent-generated code blurs. Currently, agent-specific guardrails lack cross-compatibility.

This session uses an AGENTS.md file which lives in memory for multiple chat sessions and acts as a universal agent README, providing context, instructions, and references to integrated static analysis tools (Check style, PMD, Spot bugs). This is a case study presentation that includes a live demonstration of the pipeline and quantitative data analysis.

The demonstration shows initial agent-generated code failing static analysis checks. Subsequent generation, after introducing the `AGENTS.md` file, results in an approximate 85% reduction in violations and 60% increase in unit test coverage. Attendees learn to craft `AGENTS.md` to ensure enterprise-ready, standards-compliant Java code and leverage static tools as verifiable quality guardrails.

Java, the runtime, is said to like memory. It's a fact well known to those who know it well: subtle differences in code can lead to drastic changes to applications memory and runtime profiles. We'll take you through the memory lane part of our work and show how to approach analysis, problems and troubleshooting. We'll walk through tools; what information can they surface, and how to navigate back to the code. And we'll explore how techniques and libraries affect what the application does. Attend this session if you believe troubleshooting memory in Java is “magic,” or “only tuning the GC can save us.”

Upgrading Java apps to newer version of JDKs is simple, but not so easy when you're responsible for upgrading thousands of apps. At LinkedIn, the Java team built tooling for A/B testing, performance monitoring, automation for PR creation, and drove the migration. We'll share our Java 17 migration journey (successes and surprises) as well as the road ahead for helping similar large-scale Java migrations.

The Java 17 migration we've done has huge impact, including an observed average throughput gain of 12.39% and median P99 Latency gain of 2.71%. And we've saved 3,871 hosts for 205 apps without touching a single line of application code.

Do you want to understand what's really happening inside your Java application? Are you looking to profile application behavior, analyze performance bottlenecks, or diagnose production issues with minimal overhead? JDK Flight Recorder (JFR), built into the OpenJDK, is your key to lightweight, always-on observability.

In this session, we'll take you on a guided tour of JDK Flight Recorder, the powerful event recording framework for the JVM. We'll cover the basics for getting started, show how to capture and analyze rich telemetry data, and demonstrate real-world workflows for investigating performance, memory leaks, threading issues, and more.

Attendees will leave this session with practical knowledge and live demonstrations that enable them to harness JFR to its full potential, ensuring their Java applications are robust, efficient, and easier to troubleshoot than ever before.

ZGC has evolved over the past decade from an experimental feature in JDK 11 to a robust, production-ready garbage collector powering critical online services worldwide.

ZGC is a concurrent garbage collector, meaning all heavy GC tasks are performed alongside application threads, resulting in sub-millisecond pause times. This makes ZGC a suitable garbage collector for applications where short response times are important. This talk will explore:

• A brief history of ZGC
• Its internal mechanisms
• The performance in JDK 25
• Future development plans

What makes a class a data type, and why are these classes so important? In this session we'll address the many decisions you have to make in designing such types: topics like representation, canonicalization, equality and comparison, hashing, pure functions, conversions, null handling, and more.

We'll cover many solid design practices, some of which you may have already memorized from Effective Java, but others that might be new. We'll address how you can be poised to take the best advantage of recent language features and upcoming ones as they become available. Our emphasis will be on a hygienic approach that makes your types "boring" and predictable, leaving their users few places where bugs can hide.

Keeping Java applications secure and up-to-date is crucial. Tasks like updating runtimes and third-party libraries and choosing the right cryptographic algorithms can be daunting, especially with many applications and systems. Adversaries increasingly use AI and automated tools to exploit any oversight, making it crucial to adopt tools to help us implement best practices swiftly and consistently.

We’ll showcase Oracle’s Java Management Service (JMS), a service designed to simplify Java management. We’ll cover how JMS assists in monitoring Java usage, enhancing application performance, and maintaining security compliance. We’ll share how we used JMS’s download capabilities to streamline the creation of Java container images for the Oracle Container Registry.

Project Leyden makes your application start up faster, warm up quicker, and get to peak performance sooner. How does it do this? By shifting work ahead of time. What work? Since JDK 25, Leyden has shifted class loading and linking and method profiling work off the critical path by employing training runs. The Leyden team is now working on shifting JIT compilation ahead of time as well. Come hear the details of what’s new in Leyden and what’s in the pipeline.

Get an overview of the Secure Coding Guidelines for Java and best practices. Examples will be provided to show insecure practices that may lead to security vulnerabilities. Learn how to avoid issues by applying the guidelines. We'll also cover recent updates, including expanded coverage of topics such as input validation, serialization, and more.

WebAssembly, the universal byte code for web browsers, has the potential of widening the reach of Java applications to the browser and to edge devices. It's now possible to build zero-install, shareable tools for exploration, teaching, and light coding with Java, to write browser user interfaces in Java (simplifying projects by using the same language in the frontend and backend), and do everything that at one point could be done with applets, such as games.

We'll cover:

• Technology background
• Demos of existing applications
• Survey of toolkits
• Performance data
• DOM programming
• A roadmap for a typical project
• Outlook for the future

We'll discuss specific tools such as CheerpJ, TeaVM, JWebAssembly, and GraalWasm and show some demos.

Building a compelling desktop app today requires features such as UI controls, charts, interactive media, web content, animation, CSS styling, 2D and 3D rendering, rich text, and property binding, with an easy-to-use programming paradigm that runs cross-platform. JavaFX is all this and more, delivering a rich graphical UI toolkit for building your applications and can also seamlessly interoperate with Swing.

In this session you'll learn about the new and exciting features we've developed over the past couple of years, culminating with the release of JavaFX 26. You'll also get an update on RichTextArea. We'll show plenty of demos and sample code, and finish with a sneak peek at what's coming next.

The Swing UI toolkit, along with its under-pinning by Java 2D graphics and AWT desktop integration, is still a core part of the JDK. All these and more that make up the JDK client libraries are actively updated, enhanced, and maintained for use on the latest native desktop environments. And they integrate seamlessly with JavaFX, going beyond what can be achieved using a web client.

This session will discuss how you should use Swing when deploying desktop applications and present some of the newer enhancements in progress.