Inside Java

Inside Java is a podcast for Java Developers brought to you directly from the people that make Java at Oracle. We'll discuss the language, the JVM, OpenJDK, platform security, innovation projects like Loom and Panama, and everything in between.

“Java Carrier Classes & Discussing Syntax” [AtA] 03/26/2026

“Java Carrier Classes & Discussing Syntax” [AtA] 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. /episode/index/show/insidejava/id/40628645

“Unboxing Java 26 for Developers” [IJN] 03/12/2026

“Unboxing Java 26 for Developers” [IJN] 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. /episode/index/show/insidejava/id/40409470

“Towards Better Checked Exceptions” [IJN] 03/09/2026

“Towards Better Checked Exceptions” [IJN] 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. /episode/index/show/insidejava/id/40363215

“LazyConstants in JDK 26” [IJN] 03/06/2026

“LazyConstants in JDK 26” [IJN] 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. /episode/index/show/insidejava/id/40338450

“HTTP/3 in Java” [ATA] 02/26/2026

“HTTP/3 in Java” [ATA] 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. /episode/index/show/insidejava/id/40241785

“Carrier Classes” [IJN] 02/23/2026

“Carrier Classes” [IJN] 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. /episode/index/show/insidejava/id/40198720

“Java's Plans for 2026” [IJN] 02/19/2026

“Java's Plans for 2026” [IJN] 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. /episode/index/show/insidejava/id/40164210

The New Inside Java Podcast 02/13/2026

The New Inside Java Podcast 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. /episode/index/show/insidejava/id/40096575

“Scripting Java, Collections & Generics, BeJUG” 01/28/2026

“Scripting Java, Collections & Generics, BeJUG” 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. /episode/index/show/insidejava/id/39908260

“Predictability or Innovation? Both!” with Georges Saab 12/22/2025

“Predictability or Innovation? Both!” with Georges Saab 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. /episode/index/show/insidejava/id/39492755

“From Sumatra to Panama, from Babylon to Valhalla” with John Rose 12/02/2025

“From Sumatra to Panama, from Babylon to Valhalla” with John Rose 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. /episode/index/show/insidejava/id/39234425

“From Cowboy Mode to Careful Stewardship” with Mark Reinhold 10/24/2025

“From Cowboy Mode to Careful Stewardship” with Mark Reinhold 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. /episode/index/show/insidejava/id/38766750

“Amber & Valhalla - Incremental Design and Feature Arcs” with Brian Goetz 09/24/2025

“Amber & Valhalla - Incremental Design and Feature Arcs” with Brian Goetz 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. /episode/index/show/insidejava/id/38338155

“Deprecations & Removals” with Stuart Marks 07/28/2025

“Deprecations & Removals” with Stuart Marks 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. talks to , 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. /episode/index/show/insidejava/id/37574965

“Integrity by Default” with Ron Pressler 06/23/2025

“Integrity by Default” with Ron Pressler 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. talks to , who is Java Architect at Oracle and, among other things, lead of Project Loom. /episode/index/show/insidejava/id/37115775

“Efficient Initialization Using Stable Values” with Per Minborg 06/09/2025

“Efficient Initialization Using Stable Values” with Per Minborg 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. /episode/index/show/insidejava/id/36916560

“Ahead of Time Computation” with Dan Heidinga 05/16/2025

“Ahead of Time Computation” with Dan Heidinga 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. /episode/index/show/insidejava/id/36588870

“Stream Gatherers” with Viktor Klang 05/04/2025

“Stream Gatherers” with Viktor Klang 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. /episode/index/show/insidejava/id/36425325

“Doc, JavaDoc and Markdown” with Jonathan Gibbons 01/21/2025

“Doc, JavaDoc and Markdown” with Jonathan Gibbons 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. /episode/index/show/insidejava/id/34937930

"Inside Java Weekly: JDK 24 and More" with Chad 12/20/2024

"Inside Java Weekly: JDK 24 and More" with Chad In this shorter-format pod, Chad talks about JDK 24, preview features, and more. Show Notes https://openjdk.org/jeps/11 https://openjdk.org/jeps/12 https://dev.java/learn/new-features/using-preview/ https://openjdk.org/jeps/483 https://openjdk.org/jeps/485 https://openjdk.org/jeps/491 https://openjdk.org/jeps/494 https://openjdk.org/jeps/495 https://dev.java/learn/ffm/ /episode/index/show/insidejava/id/34550905

“The Panama Effect” with Jorn Vernee 01/08/2024

“The Panama Effect” with Jorn Vernee 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. /episode/index/show/insidejava/id/29353338

“Sequenced Collections” with Stuart Marks 04/25/2023

“Sequenced Collections” with Stuart Marks 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. /episode/index/show/insidejava/id/26644944

"Preview Features: A Look Back and A Look Ahead" with Alex Buckley 03/21/2023

"Preview Features: A Look Back and A Look Ahead" with Alex Buckley 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: JEP 12: Preview Features A look ahead: /episode/index/show/insidejava/id/26290131

“Helidon Níma & Virtual Threads” 01/12/2023

“Helidon Níma & Virtual Threads” 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. /episode/index/show/insidejava/id/25584237

“Java Language - State of the Union” 12/23/2022

“Java Language - State of the Union” 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. /episode/index/show/insidejava/id/25417134

“JavaFX” 11/18/2022

“JavaFX” 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. /episode/index/show/insidejava/id/25058745

"Java 19 is Here!" 09/20/2022

"Java 19 is Here!" 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: /episode/index/show/insidejava/id/24425451

"JavaOne is Back!" 08/03/2022

"JavaOne is Back!" Chad interviews Sharat Chander about both the history of JavaOne, and what to expect with the return of it in October. Show notes: /episode/index/show/insidejava/id/23949873

“Towards Generational ZGC” 06/28/2022

“Towards Generational ZGC” 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. /episode/index/show/insidejava/id/23564936

“Java 18 is Here!” 03/22/2022

“Java 18 is Here!” 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! /episode/index/show/insidejava/id/22531148

Inside Java

TOPICS