Podcast · Tech & Science

Inside Java

by David Delabassee · English · Tech & Science

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.

New episodes: Weekly
Typical length: 17 min
Latest: 24 Sep 2026
Language: English

Latest episode

24 Sep 2026 · 33 min

"Security in Java" [AtA]

Given how prevalent Java is on web servers throughout the internet, security in Java is of critical importance. There's the security of the JDK itself, of course, which is overseen by the OpenJDK Security Group, which you should report JDK vulnerabilities to. But there are also the algorithms and features Java offers applications that are built on top of it and the cryptographic road map is an essential part of that development process. In recent years, post-quantum encryption has made big splashes but Java now also supports PEM texts and is considering the adoption of Argon2. In this "Ask…

Play episode WhatsApp Download

Earlier episodes 29 most recent

S3 · E22 · 17 Sep 2026 · 1 hr 11 min

"AOT Caching - Netflix' Practice vs OpenJDK's Theory" [I/O]

Java projects that want to reduce their launch times need to look into Java's new ahead-of-time capabilities. A training run is used to populate a cache that, in production, allows the JVM to short-circuit many operations, like class loading and linking, profile gathering, and - probably soon - JIT compilation. To get the most out this feature, a good training run is essential. Netflix approach is pretty much the ideal one: use a canary deployment of a new version to collect training data and create the cache for the remaining deployments from that. But, from time scales to checkpointing,…
S3 · E21 · 10 Sep 2026 · 16 min

"Declassifying the Java 27 Release!" [IJN]

Java 27 is heading for release on September 15th. As with every release of the JDK there are a host of changes that will impact developers, from new features, to changes in behavior of existing features. In this episode of the Inside Java Newscast we will be "declassifying" all the developer impacting changes in Java 27.
S3 · E20 · 27 Aug 2026 · 42 min

"Operator Overloading with Type Classes" [AtA]

OpenJDK's Project Valhalla is improving Java's support for custom numerical types. That goes beyond value types and also encompasses explorations into operator support. While Java is extremely unlikely to ever allow arbitrary operator definitions, it may well support limited operator overloading, so custom value types could be added or multiplied with plus or multiplication signs instead of annoying method calls. In this "Ask the Architects" episode of the Inside Java Podcast, recorded during JavaOne 2026, Nicolai Parlog talks to Joe Darcy, Valhalla committer in the Java Platform Group at…
S3 · E19 · 20 Aug 2026 · 34 min

"Keeping Up with the Java Release Train" [I/O]
S3 · E19 · 15 Aug 2026 · 10 min

"JSON API, Valhalla Progress, LTS ❤️ PQC" [IJN]

JEP 540 proposes to incubate a simple JSON API and is currently proposed to target JDK 28. The pull request for Project Valhalla's JEPs 401 and 539 were merged and value types are available as a preview feature in the latest JDK 28 early-access builds. Oracle plans to backport post-quantum cryptography to Oracle JDKs with LTS (25, 21, 17, 11, and 8) and move Java to monthly security updated (currently quarterly). JDK 28 EA builds: https://jdk.java.net/28/ Dan's mail re values: https://mail.openjdk.org/archives/list/core-libs-dev@openjdk.org/thread/Y72NRXM7KYBX43OKYBQMVKOZDWKG4MHS/ Angelos'…
S3 · E18 · 6 Aug 2026 · 14 min

"Embracing Virtual Threads with Helidon" [I/O]

Helidon 4.4 was released in April 2026 and stands out from other web frameworks by embracing new Java features as early as possible, particularly virtual threads and ahead-of-time computation. It is also aiming to become an OpenJDK project in the coming months. In this "Input/Output" episode of the Inside Java Podcast, recorded during JavaOne 2026, Nicolai Parlog talks to Joe Di Pol, Lead Principal Platform Software Engineer at Oracle where he works on Helidon. "Input/Output" is our new show, where we talk to people outside of OpenJDK to bring you their perspectives and insights into what's…
S3 · E17 · 30 Jul 2026 · 46 min

"JIT Compiler From the Ground Up" [AtA]

While Java programs are deployed as bytecode, performance-relevant code will be compiled, at run time, to machine code whose performance rivals that of any other platform. In the HotSpot JVM, this is the job of the just-in-time compilers C1 and C2 and between speculation and traps, inlining and constant folding, escape analysis and scalar replacement (and many more), they apply a number of heuristics, analyses, and transformations to achieve that. This requires expertise, careful research, thorough testing, and regular reevaluations of old assumptions. In this "Ask the Architects" episode of…
S3 · E16 · 23 Jul 2026 · 20 min

"AI Solutions with Spring AI 2.0 and Java" [I/O]

Spring AI 2.0 released in June 2026 and is one of several projects ensuring Java's continued strength in enterprise AI development. Here are some tips on deterministic agents, MCP servers and skills, prompt engineering, and where Java's richness for AI solutions stems from. In this "Input/Output" episode of the Inside Java Podcast, recorded during JavaOne 2026, Lize Raes talks to Dan Vega, Spring Developer Advocate at Broadcom, Java Champion, speaker, and author. "Input/Output" is our new show, where we talk to people outside of OpenJDK to bring you their perspectives and insights into…
S3 · E15 · 19 Jul 2026 · 10 min

"JDK 27 + Valhalla, Now! + Hackathon" [IJN]

JDK 27 entered Ramp-Down-Phase 1 in early June, so we can go over its features. Valhalla's first JDK Enhancement Proposal (401) will likely be part of JDK 28. Show off your Java ideas in the " Modern Java in the Wild" hackathon. There are two interesting articles for those who want to dive deeper into AOT with agents or into using GPU tensor cores from Java. Links: JDK 27 JEP list: https://openjdk.org/projects/jdk/27/ Valhalla mail: https://mail.openjdk.org/archives/list/jdk-dev@openjdk.org/threadAIA3O3LHFZ6T7TIPH7KZT4WS4B6U72U5/ JEP 401 PR: https://github.com/openjdk/jdk/pull/31120 "Java in…
S3 · E14 · 9 Jul 2026 · 16 min

"Scripting JS and Python with Project Detroit" with Mikael Vidstedt [AtA]

OpenJDK recently resurrected Project Detroit, an effort to ease Java's interoperability with Python and JavaScript. Interestingly, while both integrations will work through the _java.scripting_ API, there are still differences between them. On top of that, the JavaScript integration needs to explain how it related to the removal of Nashorn in JDK 16. In this "Ask the Architect" episode of the Inside Java Podcast, recorded during JavaOne 2026, Nicolai Parlog talks to Mikael Vidsted, lead of the Java Virtual Machine team at Oracle, about Project Detroit. Project Detroit:…
S3 · E13 · 25 Jun 2026 · 57 min

"How JEPs Drive Java's Evolution" with Alex Buckley [AtA]

JDK Enhancement Proposals are OpenJDK's vehicle for documenting and communicating substantial changes of the Java language, its APIs, and the runtime but also the JDK project itself, for example when it comes to development processes. Their well-defined structure and the immense care that goes into writing them make them eminently readable and understanding them well is essential to understanding Java's development. In this "Ask the Architect" episode of the Inside Java Podcast, recorded during JavaOne 2026, Nicolai Parlog talks to Alex Buckley, the Guardian of the JEP process.
S3 · E12 · 28 May 2026 · 35 min

"Java *is* Memory Efficient" with Ron Pressler [AtA]

Java's use of memory, often chided for being excessive, is actually a strength as it trades more memory use for fewer CPU cycles. Java can only make this tradeoff due to its moving garbage collectors, something more memory efficient platforms often cannot. But what's the point in leaving available memory on the table if using it makes your program run faster? Efficient use of that resource wouldn't be to leave it untapped but to use it to speed up the program. In this "Ask the Architect" episode of the Inside Java Podcast, recorded during JavaOne 2026, Nicolai Parlog talks to Ron Pressler,…
S3 · E13 · 18 May 2026 · 5 min

"Java Gets Post-Quantum TLS" [IJN]

With JDK 27 introducing hybrid key exchange schemes that combine ML-KEM with traditional ECDHE algorithms, Java applications can gain TLS-layer protection against the harvest-now, decrypt-later threat without rewriting business logic . In this episode of the Inside Java Newscast, Ana explains post-quantum hybrid key exchange for TLS 1.3 and demonstrates how a Java application can take advantage of it. See https://inside.java/podcast
S3 · E12 · 5 May 2026 · 7 min

"Make Java Safer with Flexible Constructor Bodies" [IJN]

Flexible constructor bodies were added to Java 25 with JEP 513. In this episode of the Inside Java Newscast Billy Korando will review the issues with how constructors used to work before Java 25, either forcing developers to write convoluted code, or in some cases undermining the safety and integrity of child classes. Billy will then cover how flexible constructor bodies address these issues and how Java developers can use them to write safer code and better designed applications. Make sure to check https://inside.java/podcast
S3 · E11 · 23 Apr 2026 · 58 min

"Ask the Architects at JavaOne'26" [AtA]

In JavaOne 2026's closing session, audience members had the opportunity to ask the Java architects questions. They asked about the state of structured concurrency and Project Babylon, how Java is being developed and the role AI plays in that process, the architects' pet projects, and whether they would ever consider breaking backward compatibility, etc. Make sure to check https://inside.java/podcast
S3 · E10 · 16 Apr 2026 · 10 min

"You Must Avoid Final Field Mutation" [IJN]

With JDK 26 / JEP 500 starting to prevent final field mutation through reflection, it is important that Java projects stop employing that practice. For more, check https://inside.java/podcast
S3 · E9 · 9 Apr 2026 · 17 min

"How JDK 26 Improves G1's Throughput" [AtA]

G1 is Java's default garbage collector in most environments, and its throughput has been considerably improved in JDK 26 by streamlining its write barriers. This conversation explores the background of that change and dives deep into regions, write barriers, concurrent marking, card tables, and how all that impacts throughput before eventually getting to the improvements made in Java 26, which lay further groundwork to G1 becoming the one and only default collector across _all_ environments. In this "Ask the Architect" episode of the Inside Java Podcast, recorded during JavaOne 2026, Nicolai…
S3 · E8 · 4 Apr 2026 · 5 min

"Analyzing Crashed JVMs" [IJN]

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.
S3 · E8 · 26 Mar 2026 · 46 min

"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…
S3 · E7 · 12 Mar 2026 · 11 min

"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.
S3 · E6 · 9 Mar 2026 · 13 min

"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.
S3 · E5 · 6 Mar 2026 · 11 min

"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.
S3 · E4 · 26 Feb 2026 · 43 min

"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…
S3 · E3 · 23 Feb 2026 · 10 min

"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…
S3 · E2 · 19 Feb 2026 · 9 min

"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.
S3 · E1 · 13 Feb 2026 · 5 min

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.
S2 · E11 · 28 Jan 2026 · 41 min

"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.
S2 · E10 · 22 Dec 2025 · 21 min

"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.
S2 · E9 · 2 Dec 2025 · 53 min

"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.

About Inside Java

Inside Java is a English tech & science podcast from David Delabassee. Melo plays each episode straight from the publisher's own feed — no ads added, no account needed — and remembers where you stopped, in this browser only.

Publisher: David Delabassee
Language: English
Category: Tech & Science
New episodes: Weekly
Typical length: 17 min
Latest episode: 24 Sep 2026
Feed: RSS — paste into any podcast app
Apple Podcasts: podcasts.apple.com/podcast/id1530691206
Website: inside.java/podcast
Rights: 2026 Oracle Corporation

RSS feed Apple Podcasts Website

More English tech & science 6

Take it with you

The Melo app keeps playing with the screen off, works in the car and on your watch, wakes you to your station, and browses the whole catalogue offline. Free, no ads, no account.