Inside Java

The Java tool jcmd ("j command") sends diagnostic commands to the JVM, which will react by supplying the desired information: from finalizer queues to heap and thread dumps, from GC insights to virtual thread scheduler statistics. At the moment, this requires a running JVM, but once candidate JEP 528 is adopted, a lot of that information can be seamlessly extracted from a crashed JVM's core dump, allowing easy post-mortem analysis.

Carrier classes are Project Amber's current idea to extend some of records' benefits to regular classes. Probably the most important among them is deconstruction, which would allow classes to participate in pattern matching and reconstruction. In recent weeks, there have been two mails to the Amber mailing list that describe that idea, and in this episode we discuss them both as well as the evolution between them. We also hear why syntax discussions often provide negative value and get a sneak peak at what will likely be the next Project Amber language feature. Just ahead of the JavaOne speakers dinner, Nicolai Parlog sits down with Brian Goetz, Java Language Architect in Oracle's Java Platform Group, for this "Ask the Architect" episode of the Inside Java Podcast.

Java 26 is getting all packaged up to be shipped worldwide! As with every release of the JDK there are a number of new features, improvements, changes in behavior, and more developers should be aware of before upgrading. In this episode of the Inside Java Newscast we will review all the noteworthy changes coming in Java 26 that will impact developers.

Java's checked exceptions are both an integral part of the language and one of its most contested features. Whether their introduction was a mistake and whether they should all be turned unchecked are frequently discussed topics but since the former is not overly relevant and the latter unlikely, this conversation isn't moving Java forward. Instead, let's talk about specific issues with checked exceptions and what could be done about them - from (entirely speculative) language changes to (marginally realistic) JDK/library evolution to stylistic changes.

Lazily initializing fields in Java is error-prone and undermines constant-folding. JDK 26 comes with JEP 526, which previews LazyConstant, a type that lazily initializes a value through a given Supplier. It executes that supplier at most once successfully and then assigns the value to a field annotated with @Stable, which allows constant folding. This API is also a poster child for how OpenJDK develops and evolves features.

HTTP/3 is the next version of the internet's most important application layer protocol. But, somewhat surprisingly, it uses UDP (via the new QUIC protocol) instead of TCP/IP, which has implications for the number of initial round trips, HTTP version selection, and time to first byte, but also adoption and evolution. Java 26 supports HTTP/3 out of the box. Nicolai Parlog talks to Daniel Fuchs and Daniel Jelinski, both Consulting Members of Technical Staff at Oracle and OpenJDK committers, about Java's HTTP client. They start by briefly retracing its introduction in Java 11 and its support for HTTP/2 before diving deeper into HTTP/3 to learn about the motivation, technical underpinnings like the QUIC protocol, and challenges for its adoption before discussing its integration into Java 26 Note: Sorry for the minor audio issues, thank you for your understanding.

This episode presents Project Amber lead Brian Goetz's recent email "Data Oriented Programming, Beyond Records", wherein he describes plans to improve Java's data handling capabilities by introducing carrier classes, a generalization of records. Like them, carrier classes describe their state through a component list that defines the type's external API: accessors, a constructor, and matching deconstructor - this allows carrier classes to participate in pattern matching and reconstruction. Unlike records, the implementation of this API remains the developer's task although component fields offer a shortcut for the common case where the API does map to a field. Carrier classes don't have to be final (and can hence participate in inheritance) and neither do their fields (so they can be mutable data carriers). The email also mentions carrier interfaces, allowing records to be abstract as well as a relaxation of deconstruction patterns that make them more amenable to evolution of the matched type. This episode also briefly touches on Gavin Bierman's mail to the Project Amber mailing list that announces pattern assignments and constant patterns.

In 2026, Java keeps evolving: Project Valhalla is gunning for merging its value types preview in the second half of this year; Babylon wants to incubate code reflection; Loom will probably finalize the structured concurrency API; Leyden plans to ship AOT code compilation; and Amber hopes to present JEPs on constant patterns and pattern assignments. And those are just the most progressed features - more are in the pipeline and discussed in this episode of the Inside Java Newscast.

Welcome to the new Inside Java Podcast. In this meta episode, Nicolai Parlog introduces you to the podcast's new structure with two shows under one umbrella: The long-form conversations you know become Ask the Architects episodes and they'll be accompanied by the Inside Java Newscast as a podcast.

In this special episode of the Inside Java Podcast, Nicolai Parlog talks to Adam Bien about scripting with Java, to Maurice Naftalin about the history and tradeoffs of the collections framework and erasure, and to Tom Cools about the innovative way the Belgian Java User Group organizes itself.

This Inside Java Podcast takes a meta approach. Instead of focusing on specific features, it explores the bigger picture: What are the right problems for Java to tackle? What are the current and future challenges for the Java platform? Why is predictability so important for Java, and what's driving the recent focus on learners and students? Nicolai Parlog discusses these topics with Georges Saab, Senior Vice President of the Java Platform Group and Chair of the OpenJDK Governing Board.

Java's development embraces the past as well as the future and after contributing to it for over 30 years, John Rose is intimately familiar with the process. In this episode he talks about feature design, the right amount of technical debt (which isn't actually zero), why Rice's theorem demands a mix of static and dynamic checks, how Project Sumatra eventually birthed Panama and Babylon, and more. In this episode, Nicolai interviews John Rose, Senior Architect of the Java Virtual Machine, who brings over 30 years of experience advancing the Java platform.

Java is a 30-year success story, made possible because its development consistently aligned with users' needs. In its early days, the platform required new features quickly, but over time, minimizing code breakage while carefully evolving the platform became essential. Critical junctures along that path included the introduction of modules and the current strive toward integrity by default. Nicolai Parlog talks to Mark Reinhold, Chief Architect of the Java Platform, who brings nearly three decades of experience shaping Java's evolution.

OpenJDK projects such as Amber and Valhalla are renowned for their careful and methodical approach to designing and introducing new features to the Java platform. In this episode, Nicolai Parlog is joined by Brian Goetz, Java Language Architect at Oracle and lead of both Project Amber and Project Valhalla. Brian shares insights and updates on these influential initiatives as they discuss Amber's upcoming feature arc, Valhalla's plans for null-restriction, and more.

Java is not just adding features, it's also removing old ones that became obsolete and are either a maintenance burden, performance drag, or hazardous to use. In this episode we touch on 32bit ports, applets, finalization, and the security manager. Nicolai Parlog talks to Stuart Marks, who works in the JDK Core Libraries group at Oracle. Right now, he's dressed in a lab coat and wears a stethoscope because he embodies his alter ego Dr. Deprecator. Nicolai Parlog talks to Stuart Marks, who works in the JDK Core Libraries group at Oracle. Right now, he's dressed in a lab coat and wears a stethoscope because he embodies his alter ego Dr. Deprecator.

The Java runtime offers a host of guarantees like memory safety, type safety, encapsulation, and many more. What makes these aspirations actual guarantees is a property called "integrity". But there are a few mechanisms in Java that allow undermining integrity - some for good, some for less good reasons. Integrity by default states that all such operations need to be disabled by default. Today we discuss why that is so important, what the progress toward this goal has been, and what Java developers need to know to keep their applications going. Nicolai Parlog talks to Ron Pressler, who is Java Architect at Oracle and, among other things, lead of Project Loom.

The Stable Values API is a preview feature in Java 25 that allows developers to define immutable objects that are initialized at most once. It combines the flexibility of lazy initialization with the performance advantages of final fields. In this episode, Ana hosts Per Minborg, a member of the Java Core Library team at Oracle and co-author of JEP 502 on Stable Values. Per explains the concept behind Stable Values and how this approach addresses the drawbacks of eager initialization in Java. By deferring the creation of expensive resources until they are actually needed, Stable Values contribute to more efficient application startup. He also discusses the design process and specifics of the API, highlighting its benefits in multi-threaded environments—particularly its ability to ensure thread-safe, at-most-once initialization without the need for complex synchronization mechanisms.

OpenJDK's Project Leyden aims to improve the startup and warmup time of Java applications, for now by shifting computation from those phases to the applications' build time. Java 24 ships with ahead-of-time class loading and linking, which is the first step in that direction. In this episode, we learn about that as well as about Leyden's approach to reach its goals and some features that are available in its early access build plus some that aren't. Nicolai Parlog discusses with Dan Heidinga, who is JVM Runtime Architect at Oracle and, among other things, member of projects Leyden and Valhalla.

In this episode, Ana is joined by Viktor Klang, core JDK architect and author of the Stream Gatherers JDK Enhancement Proposal, to dive into one of the standout features of JDK 24: the Gatherers API. Viktor explains how Gatherers extend the Java Stream API with custom intermediate operations, why they were added to the platform, and how they can enhance your day-to-day Java development. He also shares practical tips for using the Gatherers API effectively, along with insights into the design process and how community feedback plays a crucial role in shaping future JDK features.

Java leads by example regarding documentation: JavaDoc inspires trust in developers through its transparency on each Java API functionality, and the javadoc tool helps developers generate equally great documentation for their APIs and libraries. In this episode, Ana hosts Jonathan Gibbons, core contributor and maintainer of JDK tools, to discuss JavaDoc/javadoc developments, focusing on markdown in JavaDoc documentation comments. Given the importance of having code that is as easy to understand as it is functional, Jonathan dives into significant changes in Java's documentation component and associated tools, how JavaDoc is maintained, code documentation practices, and more.

In this shorter-format pod, Chad talks about JDK 24, preview features, and more. Show Notes JEP 11: Incubator Modules https://openjdk.org/jeps/11 JEP 12: Preview Features https://openjdk.org/jeps/12 Using the Preview Features Available in the JDK https://dev.java/learn/new-features/using-preview/ JEP 483: Ahead-of-time Compilation https://openjdk.org/jeps/483 JEP 485: Stream Gatherers https://openjdk.org/jeps/485 JEP 491: Synchronize Virtual Threads without Pinning https://openjdk.org/jeps/491 JEP 494: Module Import Declarations (Second Preview) https://openjdk.org/jeps/494 JEP 495: Simple Source Files and Instance Main Methods (Fourth Preview) https://openjdk.org/jeps/495 The Foreign Function and Memory API https://dev.java/learn/ffm/

The Foreign Function and Memory API will be finalised in JDK 22. This API helps you integrate native code within your Java program. Using this new API you can efficiently invoke code outside the JVM, safely access memory not managed by the JVM, call native libraries and process native data without the brittleness and danger of JNI. Jorn Vernee, core contributor and maintainer of the FFM API, is Ana's guest during this episode. Jorn explains what is the Foreign Memory Access API, its goals and the iterations that this API went through. Jorn also shares a few examples of Java libraries that already adopted the FFM API, the performance improvements they observed. He also explains how you can use this new API to integrate a native library within your own Java code.

Sequenced Collections, targeted for JDK 21, are a new collection type created to represent a sequence of elements with a defined encounter order. Ana recorded this episode with Stuart Marks, the owner of JEP 431 about Sequenced Collections. Stuart discusses the essence of Sequenced Collection interfaces, what needs those address and how they fit within the existing Collections framework. He explains the design of Sequenced Collections, architectural decisions and particularities of the API. He also shares his view on how Sequenced Collections can inspire future Java platform developments.

Preview Features have been essential to the delivery of Java for the past 5 years, and Java 20 is no exception with second previews of both Virtual Threads and the Foreign Function & Memory API. Chad discussing the importance of Preview Features with Alex Buckley, as well as an Informational JEP that added some further clarification for Preview Features with large surface areas. Some show notes: JDK 20 is out today: https://openjdk.org/projects/jdk/20/ JEP 12: Preview Features https://openjdk.org/jeps/12 A look ahead: https://openjdk.org/jeps/8300604

Helidon Níma is the first Java microservices framework built from the ground up on virtual threads. David recorded this episode with Tomas Langer, the Helidon architect. Tomas discusses virtual threads from a framework developer point of view. He explains Níma, its architecture and how virtual threads fit in. He also shares his views on virtual threads and some behind the scenes details and how it all started.

In this episode, David discusses with Gavin Bierman, the latest evolution in the Java Language. In addition to being a regular guest on this podcast, Gavin spends most of his time on designing new Java language features. They are chatting about Project Amber's latest features related to Pattern Matching but also the String Template feature currently in draft. Through this discussion, you will also hear about some of the tools (ex. Preview Features) but also the challenges related to the design of new Java Language features.

During JavaOne, David sat down with Kevin Rushforth (OpenJFX Project Co-Lead, Oracle) to discuss the JavaFX, OpenJFX and the new JavaFX builds that Oracle is now producing.

In this two-part episode, Chad interviews Ron Pressler, architect and lead for Project Loom, on Virtual Threads and Structured Concurrency, followed by Brian Goetz, Chief Language Architect, on Record Patterns and the arc of features in Project Amber leading to data-oriented programming. Show notes: JDK 19 JEP 425 Virtual Threads JEP 429 Structured Concurrency Game of Life by Elliot Barlas Project Loom C5M

Chad interviews Sharat Chander about both the history of JavaOne, and what to expect with the return of it in October. Show notes: Update blog series on Inside.java Register Now to get Early Pricing

In this episode, David talks with Erik Österlund about the work he did on the Z Garbage Collector, and the plans to make ZGC a Generational GC. Amongst other things, Erik shares some details on the underlying techniques, and the expected benefits.

In this special episode Chad talks with Naoto Sato on JEP 400, UTF-8 by Default, and Michel Trudeau on JEP 413, Code Snippets in Java API Documentation. To round things out, we also pulled in highlights from podcast episodes 21 and 22 to provide an overview of JEP 408, Simple Web Server, and JEP 421, Deprecate Finalization for Removal. Check out Java 18 today at Dev.java!

David remotely sat down with Julia Boes, Senior Member of Technical Staff in Dublin, to discuss the Simple Web Server (SWS). The SWS, introduced in JDK 18, is a minimal web server that serves static files. It comes with a command-line tool and an API. In this episode, Julia explains why another web server might be useful. She explains its goals, its features, who it is for but also what it is not!. She then goes over the command-line tool, its API, etc.

In this episode, David remotely sat down with Brent Christian to discuss Finalization and the effort to gradually deprecate this now outdated, brittle, and complex mechanism from the platform. After covering some of the finalization weaknesses, Brent discusses the alternatives to properly deal with resources, i.e. try with resources and the Cleaner API. He then continues with JEP 421 which will be part of JDK 18 and some potential subsequent steps.

To celebrate the Java 17 release, we have not one but two podcast episodes! In this second part, Chad discusses the evolution of the Java language with Brian Goetz, the Java Language Architect. Chad then concludes this special Java 17 episode with Stuart Marks, aka Dr. Deprecator, on the importance of deprecation!