JavaOne 2026 Sessions
May 23rd, 1995 saw the launch of not just a new programming language but an entire development and deployment platform. Initially targeted at the brand-new world of browsers and the World Wide Web, it quickly became the de facto standard for internet-scale enterprise applications. Remarkably, 30 years later, it is still always in the top three most popular languages in use by developers. How did this happen? In this session, we’ll take a whirlwind tour of the history of Java, recalling many of the milestones along the way. I started working for Sun Microsystems in February 1996, roughly the same week JDK 1.0 was launched. Through 14 years at Sun, five at Oracle, and nearly 10 at Azul, I’ll bring plenty of anecdotes about Java’s history (and some souvenirs). Be prepared for some serious developer nostalgia!
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.
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.
We'll review new and upcoming Java features that improve the convenience, reliability, and performance of immutable data, including:
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.
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).
JVMs power applications and infrastructure across cloud environments. Traditionally, JVMs have operated with a pre-cloud mindset, functioning independently of the cloud’s infrastructure and capabilities. This talk will discuss cloud native JVMs: JVMs that not only run in the cloud but actively leverage its environment to optimize performance and contribute value back to the ecosystem. We’ll focus on fleet-wide profiling, code optimization, and experience orchestration, showcasing how Cloud Native Compilation and Profile Orchestration can significantly enhance execution. The session explores code optimization in traditional vs. cloud native JVMs, covering improvements in speed, deployment, startup, and sustained performance.
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.
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 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.
Learn how Netflix used Project Leyden to improve startup time of critical services and the software and SDLC we built to make that happen.
Java doesn’t evolve by accident, and Brian Goetz is at the center of this evolution. In this keynote, the chief language architect offers a behind-the-curtains view of what it’s really like to steward a language that powers half the global GDP. You’ll walk away with a clearer sense of how major technical decisions get made—and how that perspective can shape the way you design and build applications today. If you’ve seen Brian speak before, you already know that this is one you won’t want to miss. And maybe he’ll finally answer: “Valhalla when?”
Come gain hands-on experience with modern Java features including compact source files, flexible constructor bodies, instance main, enhanced JavaDoc, unnamed variables, and more. Enrich your experience and expertise to take your Java skills to the next level!
The Java language supports generic classes and methods, since 2004. Using generics, you can write one sort algorithm or one list data structure, and use it everywhere, for many types. This works because a generic data structure or algorithm embodies a pattern of code and/or data that works regularly and reliably for the requested types (These are called "type arguments").
For example, List is a Java interface, and Arrays.sort is a static method. Because List and Arrays.sort are both generic, they can be used safely across many type arguments. A list can contain strings, ints, or frogs. A call to Arrays.sort can sort an array of the same variety of things (assuming frogs can be compared).
Java generics look like C++ templates; in fact, generics and templates share many characteristics. But there is an interesting difference: A Java generic method can be called either with static types (as in C++) or dynamically typed objects (as in JavaScript or Lisp), whereas a C++ template can only expand when given static type arguments.
The difference affects optimization and execution speed. A C++ template stamps out a distinct pile of specialized object code for each template instance. But a Java generic method has two jobs. It should optimize like a template, but it must also offer a single entry point that can operate on dynamic types. It is a little like a C++ template that has one extra "raw instance" that emulates all the other instances.
But how can such a thing optimize, if it must handle both static and dynamic callers? That is the question we tackle in this talk.
Taking the above language features as given, this session deep dives into how the Java Virtual Machine (JVM) processes generics. We will use a small running example, a toy QuickSort algorithm. Running it in various way, we will observe how the JVM can optimizes quick-sorting of arrays of varying types. We will observe a triad of interconnected techniques: type profiling, inlining, and devirtualization. It all works beautifully, just as fast as C++ templates, within certain limits.
We will probe those limits, specifically a problem called profile pollution (or saturation), which blinds the JVM compiler to specialized types, with cascading failures of devirtualization and inlining. When this happens, semantics are preserved (the program produces a correct answer) but there can be a "performance cliff". Parity with C++ templates breaks down, because the program executes as if dynamically typed (only). The answer takes longer to get.
But all is not lost! We will examine a range of tactics, current and future, that can ward off the performance cliff. Either the type profiles must be cleaned up somehow, or there must be an alternative means of supplying the missing type information.
Although much of this technology is three decades old, this talk is timely, because generics are facing new challenges. Project Valhalla will soon deliver a large new language and JVM feature, value classes. A value class instance is no longer a simple polymorphic pointer, so friendly to generic code of the past. A value class is often processed as a small headerless struct.
Inside the JVM, an array of class instances used to be a uniform sequence of dynamically typed pointers, but with Valhalla can look just like a C++ array of structs or C++ objects. This can make some generics harder to optimize, since now the data layout can vary wildly. How does a quick-sort algorithm swap two array elements, when each element might be one pointer, two pointers, a pointer and an int, two ints, or any other combination of field types? Where is C++ template expansion when you need it? There are some partial answers in the short term, which we will demonstrate in today's JVM (as of Java 25).
A long-term answer to this challenge, called "generic specialization", has the JVM do some extra bookkeeping for generic classes and methods, tracking statically-specified type arguments at generic call sites. Using this extra data, the JVM can recompile specialized versions of the code, for a single type argument, just like templates. Of course, the JVM must ensure that this specialization is only called where it is truly applicable. And the specialization should be done only in "hot spots" where the extra compilation work will pay off.
We are not ready to roll out full generic specialization, but we can experiment now with low-level JVM optimizations, that demonstrate the possibility of robust parity with C++ template performance. Today's quick-sort adventure is a step along that path, motivating and informing our next steps. Join us on the journey to Valhalla generics!
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:
... before taking a closer look at the newest release, including its preview features:
There are plenty of features in the language, API, and runtime to discuss; whether new, improved, or finalized. Let's go over them.
In this hands-on hack session, you will learn why you want to use Java not just for big-iron projects, but for small tasks. Shell scripts become more robust in Java. Notebooks no longer force you into Python. With a bit of tool support, modern Java makes it easy...and typesafe. Bring your laptop and work through some prepared challenges or bring your own! You will come away with an appreciation of new use cases for the programming language you already use and love.
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.
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.
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.
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.
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.
The Foreign Function & Memory API (FFM) was finalized in JDK 22 and has undergone several performance improvements. JDK 25 is the first release that includes the FFM API and has broad long-term support. 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.
Get 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.
We rely heavily on polymorphism when programming with the object-oriented paradigm. That has served us really well, especially to create extensible code. However, like any tool and technique, there are times when that may not be the right choice. Java now provides an alternative that is useful in those select situations—the data-oriented programming. In this presentation we will start with an example where the highly useful object hierarchy and polymorphism appear as a misfit and discuss how data-oriented programming solves the problem more elegantly. Get a good understanding of when to use each one of these and how to intermix them in your applications.
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.
Everyone knows Java programs use a garbage collector and that the JDK offers a choice of several GCs with different characteristics. But all of the JDK’s garbage collectors share important design aspects that set them apart from garbage collectors used in other languages, and that Java developers should know. In this talk, we’ll cover why the JDK’s garbage collectors work the way they do and how the JDK’s memory management impacts program performance. In particular, we’ll explore the interesting and sometimes non-obvious relationship between RAM and CPU, and why we must always consider them together. We’ll also ask whether Java is wasteful by using too much memory or whether it's other languages that are wasteful by using too little.
Modern Java applications running in cloud environments face a challenge: startup time is no longer just a JVM concern—it directly affects autoscaling behavior and infrastructure cost. In elastic platforms, cold starts delay capacity availability, increase CPU usage during warmup, and lead to temporary overprovisioning. At scale, these effects accumulate into measurable infrastructure cost. In this session, we explore how Java's AOT Cache improves startup and scaling efficiency while preserving the HotSpot execution model. We break down the JVM startup path, identify where cold starts and warmup consume CPU cycles, and explain how AOT Cache reduces repeated profiling and tiered compilation work across instances. The result is a pragmatic approach to reducing cloud cost in large-scale Java deployments without changing application architecture or runtime semantics.
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.
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.
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.
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.
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.
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.
In this hands-on hack session, you'll discover how langchain4j-cdi lets you integrate GenAI capabilities into your Jakarta EE and MicroProfile applications using familiar CDI patterns. Just like injecting an EntityManager, you'll learn how to @Inject AI Services, configure LLM providers, and build AI-powered features—all within your existing enterprise Java stack. Bring your laptop and be ready to code!
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.
Enterprises increasingly rely on agentic AI to improve productivity, integrate siloed business data, and drive secure, automated decision-making. Yet most encounter complexity in managing models, orchestration logic, and governance at scale. Oracle’s new OCI Generative AI Agent Hub addresses that with an end-to-end experience for orchestrating and running AI agents.
In this session, we’ll show how Java developers can use the OCI OpenAI SDK for Java to connect to LLMs, extend existing enterprise logic, and manage multiagent workflows.
Join us to learn how the Agent Hub brings flexibility, reliability, security, and privacy that enables enterprises to confidently build, deploy, and operate agentic AI at scale.
In this hack session, you will learn how to build and deploy production-ready AI agents. You will use Spring AI, MCP, Java, and Amazon Bedrock, and learn how to deal with production concerns like observability and security. We will start with basic prompting then expand with chat memory, RAG, and integration through MCP. In the end, we will have a multiagent system where agents interact with other agents to accomplish high-level tasks.
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:
Who should attend:
Leave with a production-ready pattern for building scalable AI agents and services with Helidon, Virtual Threads and LangChain4j.
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 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.
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.
GitHub Copilot is a programmable AI platform, and I can show you how! In this quick session, we'll explore the Java SDK for Copilot, which brings programmatic control of the Copilot CLI and its agents to the Java ecosystem. We will see how to create conversational AI sessions, register custom tools, handle streaming events, and integrate MCP servers, all from Java code. We'll also pull back the curtain on how we used AI coding agents to build and maintain the SDK: from automated upstream syncing with the official Node.js and .NET reference implementations, to agentic merge workflows, documentation and test coverage assessments, and PR automation: all orchestrated through GitHub Copilot's own agentic capabilities. Whether you’re looking to extend Copilot or rethink how you ship software with AI, this talk has something for you!
In this HOL, explore how to build a multi-agent system from the ground up using Spring AI. Youll learn how to get multiple agents working together, each with its own role, memory and context. All inside a clean, production-ready architecture.
AGENDA
Throughout this interactive session, explore practical patterns and real world challenges as you:
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.
You CAN build production AI applications entirely in Java—and you should. This talk proves it.
We built SkillsPilot, an AI-powered SaaS handling sensitive HR data for enterprise clients, using a complete Java stack. No Python microservices. Pure Java from database to dashboard.
The stack: Cassandra + pgvector for data, Langchain4j orchestrating multiple LLMs, Spring Boot for business logic, multi-platform frontends (webforJ, Flutter, CarPlay)—all Java-powered.
Real production patterns: type-safe AI services, parallel multi-LLM orchestration, RAG with vector embeddings, cost optimization via caching and spot instances.
18 months in production: 99.9% uptime, <200ms latency, 10,000+ concurrent users, 70% cost savings.
Java's strengths—type safety, concurrency, mature tooling—become superpowers for AI. Real company, real customers, real revenue. All Java.
Walk away with architecture diagrams, code examples, and confidence to build enterprise AI in Java.
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.
In this hack session, we’ll cover using AI libraries accelerated with GPUs and Vector API, as well as address use cases, benchmarks, and best practices. We’ll also explore lessons learned from building these libraries and patterns, and finally offer recommendations for using these API to accelerate Java application performance in general. You’ll walk away learning how to build and use the fastest neural networks in Java for your applications.
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.
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.
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.
As AI continues to reshape the enterprise landscape, Java developers are uniquely positioned to build and scale the next generation of intelligent applications. This session explores the critical intersection of modern Java and the evolving enterprise AI ecosystem.
We'll break down the current AI and data processing landscape, demystifying how it directly correlates to everyday Java development and enterprise GenAI initiatives. Finally, we'll take a look
under the hood at emerging technologies—including the code reflection engine being built into Project Babylon—and discuss how these advancements will empower developers to write more
efficient, AI-ready code.
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.
You’ve heard the buzz, now roll up your sleeves and build with it. In this session, you’ll learn exactly how the Model Context Protocol (MCP) works and write your own MCP server tool from scratch, then author an agent that uses it to deliver real-time, context-aware help right inside your dev flow. We’ll break down the raw MCP protocol step by step:
• How it streams context between your IDE and agents
• How messages are structured and exchanged
• How to wire up an MCP Client to talk to your new tool
By the end, you’ll not only understand the protocol, you’ll have built a working MCP server tool and your own agent that plugs into it to automate tasks, provide better suggestions, and boost your
productivity. Bring your curiosity because you’ll walk away with practical code, a working prototype, and the confidence to build and extend your own MCP-powered tools and agents.
This session will surface progress JEP 528 which brings core and minidump support to jcmd. The jcmd tool supports the monitoring and troubleshooting of a running HotSpot JVM. JEP 528 will extend jcmd so that it can also be used to diagnose a JVM that has crashed. This will establish a consistent experience in both live and post-mortem environments.
Enterprises adopt open models to control cost, latency, and IP. This session shows how Java teams select, integrate, and operate LLMs using platforms and tools like LangChain4j and vector search to run locally and the cloud. It covers benchmarking, model size vs. throughput, memory footprints on the JVM, response-time tuning, and safety layers. It highlights where the latest GenAI Java projects complement inference pipelines and how to evaluate RAG quality with reproducible metrics. Attendees see end-to-end flows, from data grounding to deployment, with attention to observability, configuration, and rollback strategies.
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.
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.
AI agents are rapidly moving from prototypes to production, yet most still rely on naive textual prompts, resulting in fragile systems. At JetBrains, we built Koog, the most advanced framework for developing AI agents on the JVM. Initially built for Kotlin, it now features a new idiomatic Java API! In this talk, I'll show how Domain Modeling, Java's type system, and Koog make AI agents more reliable.
You'll learn:
Why domain modeling outperforms naive prompting
How to easily build reliable AI agents in Java
JetBrains' lessons from building real-world AI agents on the JVM
How to architect scalable, enterprise-ready AI systems with Koog
JVM is the best platform to build enterprise-grade AI agents. Why? Join this talk to learn!
Uber's Michelangelo platform powers thousands of latency-critical machine learning models, from real-time ETAs and marketplace optimization to large-scale deep learning and LLM inference. As we enabled GPU-backed online inference, the serving stack experienced a 10–100× increase in traffic, with per-service QPS growing from the hundreds into the 10K+ range. While GPUs dramatically improved model throughput and cost efficiency, this sudden traffic amplification exposed new bottlenecks across Java-based inference services.
In this talk, we share how Uber scaled GPU-accelerated inference while maintaining strict tail-latency SLOs in a JVM-centric production environment. We describe how Java services integrate with NVIDIA Triton Inference Server to serve models ranging from small neural networks to multi-hundred-gigabyte LLMs, and how GPU efficiency techniques—such as Multi-Instance GPU (MIG), model disaggregation, and dynamic batching—shifted pressure onto JVM memory management, garbage collection, threading, and metrics pipelines.
We dive deep into the JVM tuning techniques required to handle this traffic surge, including heap sizing strategies, G1GC pause-time tuning, executor thread configuration, off-heap memory considerations, and CPU/GPU resource isolation in containerized deployments. We also share production lessons learned from operating thousands of Java inference services, including the impact of Java upgrades, service warm-up strategies, and metrics optimizations under extreme QPS.
Attendees will leave with practical guidance for running low-latency, GPU-accelerated inference from Java, and concrete patterns for scaling JVM-based services when hardware acceleration fundamentally changes traffic dynamics.
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 API for Java—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 atomically. By the end, Java developers will understand how to unify streaming and database operations to build resilient, intelligent, multi-agent systems.
Join this JavaOne Hack Haus session to collaboratively create a system use case, use AI to generate a full-stack Java application, and evolve the features live by changing the specification, all by demonstrating how to keep code and tests in sync and reduce hallucinations with strong guardrails. The hack session can be done with any AI agent, and we can compare the outcomes.
Whether you’ve built your own AI agent or are using an AI coding agent, the things that give the agent “agency” are the augmentations and integrations provided to it. There are many different strategies and approaches to these integrations: tools, agent skills, MCP, and many others. This session will provide Java-based technical examples of top strategies and the use cases which fit best with each. You will learn how and when to apply these strategies for your own Java agents and when building Java systems with the help of AI code agents.
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.
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.
“The era of humans writing code is over” —Ryan Dahl.
LLMs are getting better at generating code that works, but they still introduce vulnerabilities at a troubling rate. This session addresses the security risks that emerge when Java code is generated by GenAI assistants and shipped at scale. Risks such as injection vulns that slip without proper input validation, authz bypasses, data leaks, and deserialization gadgets. In today's SDLC reality, code generation and ownership is fragmented. This session makes the case for runtime-first security:
If Java code is generated by prompts, then IAST and RASP are mandatory controls, not niche tools.
As the industry moves forward, how do we ensure our classrooms don't fall behind? This BoF is a collaborative space for educators to process the technical announcements and industry shifts showcased at JavaOne 2026. We will discuss which conference takeaways are "must-haves" for our next syllabus and which are just passing hype. Bring your questions and observations from the sessions you’ve attended: How do we adapt our teaching to the conclusions shared by industry leaders? Join us for an informal brainstorming session on evolving our pedagogy to keep pace with the professional Java ecosystem.
As the industry moves forward, how do we ensure our classrooms don't fall behind? This BoF is a collaborative space for educators to process the technical announcements and industry shifts showcased this week. We will discuss which conference takeaways are "must-haves" for our next syllabus and which are just passing hype. Bring your questions and observations from the sessions you’ve attended: How do we adapt our teaching to the conclusions shared by industry leaders? Join us for an informal brainstorming session on evolving our pedagogy to keep pace with the professional Java ecosystem.
With so many tracks and keynotes, it’s easy to feel like you're drowning in information. This session is an open forum to "debrief" on everything you’ve seen at JavaOne 2026. What was the most exciting (or confusing) thing you heard? Is there a new library or methodology everyone's talking about? We’ll gather to share our biggest "aha!" moments, clarify complex concepts together, and discuss how the trends we've seen at the conference will change the way we learn and build projects back on campus. Students helping students make sense of it all.
Presented by industry experts that have spent the last 20+ years helping developers grow their careers, this session offers invaluable insights and guidance tailored to the specific needs of technical professionals.
Who Should Attend:
Technical professionals seeking structured career growth.
What to Expect:
Develop the right skills to advance your career and learn how networking and community engagement accelerate professional growth.
Mentoring Information:
Moving from an individual contributor to a tech leader requires new skills beyond coding. Learn how to navigate this transition while staying hands-on with technology.
Who Should Attend:
Senior developers looking to transition into leadership roles
What to Expect:
Identify the key leadership skills needed beyond technical expertise. Learn how to balance hands-on coding with strategic decision making. Understand how to mentor and guide teams effectively.
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.
Let's go through a couple of the aspects to consider when you are starting your open source journey. We will also look at how this can help your career whether you want to build a career in open source, or how it can help as a stepping stone to boost your existing career path.
Who Should Attend:
Don't know where to start with Open Source? Or want to be better at convincing your boss? Or you have anything else stopping you from contributing to open source? Then this session is for you.
What to Expect:
How do I get started with Open Source?
What can I contribute?
Where should I start?
Growing in your career goes beyond writing good code. It’s about connecting, sharing, and showing up. In this mentoring session, learn three simple actions that help developers gain visibility, strengthen their skills, and open up new opportunities through the community.
Who Should Attend:
Professional developers.
What to Expect:
You’ll discover how sharing knowledge, building real connections, and actively participating in communities can transform your professional journey, while you learn, teach, and have fun.
Stuck at senior level, and unsure on how to do the next step of your career? Come discuss what you can do to reach the best positions in the market, increase your salary, and create huge impact, all while working in a cool tech position.
Who Should Attend:
Senior technical professionals like developers, architects, designers, sys-admins and more.
What to Expect:
Discover the 5 paths to grow beyond senior
Identify the needed skills and opportunities
Learn how to acquire those skills fast in your current job
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.
Interested in speaking at conferences or user groups but not sure where to start? In this mentoring session we can talk about how to come up with talk ideas, prepare a proposal, submit to events, and deliver a great presentation. We'll also discuss how speaking can help you grow professionally and become more involved in the developer community.
Who Should Attend:
Developers who are interested in giving their first talk, as well as those who have spoken before and want to improve their conference speaking skills.
What to Expect:
Participants can expect practical tips on how to create talk ideas, write strong CFP submissions, prepare engaging presentations, and get involved with conferences and user groups. Takeaways will vary depending on the discussion and the questions brought by attendees.
Explore practical ways to move GenAI and RAG from experiments into real production applications.
Who Should Attend:
Java engineers and architects interested in applying GenAI in real systems.
What to Expect:
Bring your questions, ideas, and challenges. Together we’ll explore how to design practical GenAI solutions.
How networking can help boost both workplace and external presence
Who Should Attend:
Beginners and anyone else interested in learning to how to improve professional networking skills in the IT industry.
What to Expect:
Benefits of networking, techniques of networking, and more.
Compact Source Files and Instance Main Methods simplified the "Hello World" experience for students. But when curriculums still lead with classes and objects, it undermines the goal of eliminating upfront complexity. In this session we will show how a computer science curriculum can avoid forcing complexity on a student before they're ready for it.
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.
Using AI coding assistants and integrating AI features into applications can be incredibly powerful but also comes with security implications and architectural considerations.
Who Should Attend:
Developers using AI tools or integrating AI capabilities in their applications.
What to Expect:
Hear an overview of how to use AI and LLMs for coding and building applications in a secure way.
What does it takes going from a good midlevel dev to become a senior developer? How about a senior architect?
Who Should Attend:
Developers who want to take the next step in their career development.
What to Expect:
Open discussions, identifying opportunities, talking through the real cases participants bring to the table.
Have you ever thought about writing a book or doing some teaching? Come to this session and bring your questions.
Who Should Attend:
Anyone who is interested in writing or teaching is welcome to attend.
What to Expect:
Have questions answered about writing and teaching, and become more motivated to start achieving these goals.
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.
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.
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.
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.
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:
If you run real Java systems, this session gives you the map, the risks, and the safe route forward.
Running enterprise Java applications across multiple cloud platforms gives more features and freedom from hosting efforts—until visibility and quick analysis becomes bigger problem. Logs are placed in different environments, metrics becomes confusing, alerts are over engineered, and tracing failures across AWS and Azure feels like day long job. In this session, I’ll walk through how we built a unified observability tool for an application deployed on production across AWS and Azure, using OpenTelemetry, KQL, CloudWatch Logs Insights, and Grafana. We’ll cover how to correlate metrics, logs, and traces from both cloud providers, detect silent failures, and build useful monitoring tool in analysing production issues. This method can be very customised based on your application and requirements. We will learn how we combined data from two clouds to monitor health of our deployed application without dependency on external tool.
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:
We'll also generate idiomatic Java 25 code that's both machine-readable and human-friendly. Questions and discussion are encouraged throughout.
Caixa Econômica Federal (CAIXA) in't just a bank; it's the financial backbone of Brazil, serving over 150 million citizens. With a volume of 8 billion transactions/month, CAIXA faces engineering challenges that demand resilience and concurrency. This session shows how CAIXA leverages a robust architecture to sustain this hyperscale operation. You'll explore the journey from monolithic systems to modern ecosystem where Java microservices (Spring Boot and Quarkus) orchestrate complex interactions between digital channels and core ledgers. We'll discuss the partnership with Oracle, using Exadata Cloud@Customer to ensure the data persistence needed by the instant payment system, which processes over 40 million daily operations. Learn the patterns used to handle traffic spikes during national social benefit payouts. We'll dissect how the synergy between Java's agility and Oracle's robust infrastructure empowers CAIXA to bridge the gap between legacy reliability and cloud-native innovation.
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.
Upgrading Java isn’t just about keeping the lights on—it’s an opportunity to harden security, boost performance, and simplify operations. In this session, you’ll learn how to use Oracle Code Assist to plan and execute a confident upgrade to the latest Java LTS, moving beyond basic API compatibility to deliver measurable gains.
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:
For 25 years, IntelliJ IDEA has grown alongside the Java ecosystem—shaped not just by technology, but by the people behind it. In this keynote, we’ll reflect on how close collaboration with the Java community helped IntelliJ IDEA evolve from a developer-focused idea into a tool trusted by millions. From early support for new Java features to active participation in OpenJDK, the JCP, and Java User Groups, JetBrains has always built tools with the community, not just for it. Looking ahead, we’ll share how JetBrains continues to support the Java ecosystem through open tools, deep ecosystem integration, and long-term commitment to developer productivity as Java and its community keep moving forward together.
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.
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.
Caching is a first-class architectural concern in agentic systems. This talk breaks down how Java applications can layer internal, distributed, and semantic caches. We'll explore in-process caching with Caffeine for ultra-low-latency access, distributed caching with Redisson and Valkey for shared cache and semantic caching using Vector Similarity Search to reduce latency and cost while scaling LLM access.
Copilot is quickly becoming part of everyday development, but the real power unlocks when you embed it into the tools developers already use. GitHub Copilot CLI makes Copilot available in the terminal, and the Copilot Community SDK for Java takes it a step further by enabling Java applications to integrate with Copilot programmatically.
In this session, we will explore how Copilot CLI works, what the Copilot CLI server provides, and how Java developers can call it as part of custom workflows. Then we will dive into the design of the Java SDK.
If you build Java developer tools, CI/CD automation, or internal platforms, this talk will give you the building blocks to bring Copilot-style experiences directly into your product.
You've inherited a Swing application. Or it's Eclipse RCP. Or maybe Oracle Forms. Leadership wants it "on the web." The conventional wisdom says: rewrite everything, build a React frontend, expose REST APIs, hire JavaScript developers, and prepare for months (or years) of integration headaches. But what if you didn't have to? This session challenges the assumption that Java teams must adopt dual-stack architectures to deliver modern web experiences. We'll explore a pragmatic modernization path that keeps your entire stack in Java - preserving your team's expertise, your existing business logic, and your sanity. You'll see two complementary approaches in action: Webswing, which runs your existing Swing, JavaFX, Eclipse RCP, and even Oracle Forms applications in the browser with minimal changes, and webforJ, a modern framework for building web UIs in pure Java. Together, they enable a phased migration strategy where you can deploy legacy code to the web today while incrementally building modern interfaces - all without writing a single line of JavaScript. We'll demonstrate real migration scenarios, discuss honest trade-offs, and share production lessons learned. Whether you're maintaining a 20-year-old Forms application, an Eclipse-based desktop tool, or architecting greenfield projects, you'll leave with practical strategies for delivering web applications while staying in the language you know best.
Every production Java application depends on a myriad of binaries somebody else built, patched, tested, and certified. But who funds that pipeline?
And what happens when parts of it go dark?
This session maps the real economics of open-source sustainability through the Java ecosystem: the infrastructure costs behind certified binaries, the EU Cyber Resilience Act's 2026 compliance deadlines, and the mounting pressure on maintainers from AI-generated noise.
Java's layered ecosystem: coordinated quarterly security, vendor-neutral distributions, foundation governance, and strong commercial stewardship - is better equipped for this moment than any other platform. But even here, your open-source stack is accumulating risk in ways you might not expect.
We'll challenge some comfortable assumptions about how open-source software is really maintained and secured, including a blind spot most organisations miss entirely: end-of-life dependencies your scanners report as clean, because nobody upstream ever checked.
You'll walk away with a method for finding EOL components your scanners miss, and a clear view of when third-party EOL support makes more sense than a rushed migration.
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.
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.
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.”
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.
The less time we spend writing code, the more time we spend debugging code someone else wrote (read: LLM-generated). These days we barely write code ourselves—the robots do it for us (almost joking). What we really need in our IDEs aren't features that help us write code faster, but ones that help us understand and debug LLM-generated code. That’s where the new Spring Debugger comes in. It reveals what’s really happening inside your Spring Boot app: tracing values back to property sources, inspecting configuration resolution, following context initialization, visualizing bean creation and dependency graphs, and stepping through transaction boundaries. If you’ve ever asked yourself, “Where should I click to find out?”, this talk is your answer.
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.
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.
“Full Stack Developer” often means working across HTML, CSS, JavaScript frameworks, databases, and cloud services—powerful, but a lot to manage and maintain. What if building modern web applications didn’t require a full stack at all? At the JavaOne Hack Haus, we’ll explore how far you can go using mostly Java. We’ll live-demonstrate building enterprise-ready UI and persistence using open-source technologies like Vaadin and EclipseStore, and we’ll discuss trade-offs, productivity, onboarding, and long-term maintenance. Drop in, ask questions, challenge assumptions, and see how small a stack can realistically become.
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:
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.
Join us from 7:00 p.m. - 10:00 p.m. for the JavaOne 2026 Attendee Party at Devil's Canyon Brewery.
Meet Java author Barry Burd and get a signed copy of Java For Dummies, 9th Edition. A limited number of books will be available, so stop by early to meet the author and take home a signed edition.
Meet Java author Cay Horstmann and get a signed copy of Core Java, 14th Edition, Oracle Press, 2026. A limited number of books will be available, so stop by early to meet the author and take home a signed edition.
Meet Java authors Bruno Souza & Heather VanCura and get a signed copy of Developer Career Masterplan: Build Your Path to Senior Level and Beyond with Practical Insights from Industry Experts. A limited number of books will be available, so stop by early to meet the author and take home a signed edition.