Alle afleveringen
74 afleveringen, van nieuw naar oud
-
"Valhalla? AI? Better Modules? String Templates?" [AtA]
5 november 2026 · 46 min
This episode of the Inside Java Podcast is the Ask the Architect session from Devoxx Belgium 2026, where the audience members literally asked the Java architects their questions. They inquired about custom virtual thread schedulers, AI's impact on the development of Java itself, Valhalla features, string templates, better modules, and more. Lees meer
-
"Immutable Data Beyond Value Classes" [AtA]
29 oktober 2026 · 54 min
Object-Oriented Programming offers a lot of flexibility for modelling diverse domains but not all elements need that flexibility. Data, specifically, is often better modeled by simple, immutable types and while OOP does not prevent that, it can make it a bit cumbersome. So in recent and coming years, Java has gained and will gain a number of features that improve the situation: From flexible constructor bodies to records and value classes, from withers to lazy constants, and more - they all stand on their own, but they also come together to allow us to more expressively and elegantly define, construct, copy, and access immutable data. Lees meer
In this "Ask the Architects" episode of the Inside Java Podcast, recorded during JavaOne 2026, Nicolai Parlog talks to Dan Smith, contributor to projects Amber and Valhalla and Senior Java Platform Developer at Oracle.
Show Notes:
Better Tools for Immutable Data: https://www.youtube.com/watch?v=BdLND9D81lI
JEP 513: Flexible Constructor Bodies: https://openjdk.org/jeps/513
JEP 401: Value Objects (Preview): https://openjdk.org/jeps/401
JEP 468: Derived Record Creation (Preview): https://openjdk.org/jeps/468
JEP 547: Lazy Constants (Fourth Preview): https://openjdk.org/jeps/547
-
"OpenJDK Bug Fixing, JavaOne, and JDK 28" [IJN]
17 oktober 2026 · 8 min
On August 18th, 2026 a mail pops up on the hotspot-compiler-dev mailing list and it describes something that is not supposed to happen: a serious new bug in a JDK release candidate phase, just a few weeks before general availability. Apparently, under very specific circumstances, some buffer contents aren't correctly copied and strings can get corrupted. This is bad, very bad even, and obviously requires analysis and a fix. This is the story of the structure and community that fixes bugs like these and how they operate. We also take a quick look at JavaOne, the Inside Java Podcast, and JDK 28, which is shaping up to be a big release. Lees meer
Links:
A critical bug:
JEP 3: https://openjdk.org/jeps/3
the original issue: https://bugs.openjdk.org/browse/JDK-8373591
the original PR: https://github.com/openjdk/jdk/pull/28789
Lorenzo's bug description: https://mail.openjdk.org/archives/list/hotspot-compiler-dev@openjdk.org/thread/5NVKBE3C5T5ULKVO5T3RTUQZDIXQMHBE/
Chris' alarm for the P1 bug: https://mail.openjdk.org/archives/list/jdk-dev@openjdk.org/thread/EPJNIMIAROC2QELIZE5MAGU4D6S3FEVG/#K52LJL4HZJE565UBU465PT4ZBRC2XV4Y
the bug in JDK 27: https://bugs.openjdk.org/browse/JDK-8390546
backing out the change on the mail branch: https://bugs.openjdk.org/browse/JDK-8390590
backporting the backout to JDK 27: https://bugs.openjdk.org/browse/JDK-8390663
Mark's confirmation: https://mail.openjdk.org/archives/list/jdk-dev@openjdk.org/message/K52LJL4HZJE565UBU465PT4ZBRC2XV4Y/
redoing the change on the main branch: https://bugs.openjdk.org/browse/JDK-8390617
Quality Outreach: https://wiki.openjdk.org/spaces/quality/pages/18448461/Quality+Outreach
JavaOne: https://javaone.com
JDK 28:
early-access builds: https://inside.java/podcast/
feature list: https://openjdk.org/projects/jdk/28/
-
"Security in Java" [AtA]
24 september 2026 · 33 min
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. Lees meer
In this "Ask the Architects" episode of the Inside Java Podcast, recorded during JavaOne 2026, Nicolai Parlog talks to Sean Mullan, Lead of the OpenJDK Security Group and Tech Lead of the Oracle Security Libraries Team.
"Ask the Architects" is our podcast show, where we talk to experts in OpenJDK about their work on the Java language, API, and runtime.
Show notes:
OpenJDK Security Group: https://openjdk.org/groups/security/
Oracle JDK Cryptographic Roadmap: https://www.java.com/en/jre-jdk-cryptoroadmap.html
Post-Quantum Hybrid Key Exchange for TLS 1.3: https://inside.java/2026/02/17/tls-post-quantum-hybrid-key-exchange/
JEP 542 - PEM Encodings of Cryptographic Objects: https://openjdk.org/jeps/542
JEP Draft for Argon2: https://openjdk.org/jeps/8377081
-
"AOT Caching - Netflix' Practice vs OpenJDK's Theory" [I/O]
17 september 2026 · 1 uur 11 min
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, from managing to inspecting cache files, there are a number of details to consider. Lees meer
In this "Input/Output" episode of the Inside Java Podcast, recorded during JavaOne 2026, Nicolai Parlog talks to Martin Chalupa, Senior Performance Engineer at Netflix and John Rose, JVM Architect at Oracle and Lead of OpenJDK's Project Leyden.
"Input/Output" is our new show, where we talk to people outside of OpenJDK to bring you their perspectives and insights into what's happening in the Java ecosystem. This special episode comes with an OpenJDK architect to boot.
Show notes:
JDK 27: https://jdk.java.net/27
Project Leyden: https://openjdk.org/projects/leyden/
Martin's talk at JavaOne 2026: https://www.youtube.com/watch?v=4kEh8hxAP4U
-
"Declassifying the Java 27 Release!" [IJN]
10 september 2026 · 16 min
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. Lees meer
-
"Operator Overloading with Type Classes" [AtA]
27 augustus 2026 · 42 min
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. Lees meer
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 Oracle.
"Ask the Architects" is our podcast show, where we talk to experts in OpenJDK about their work on the Java language, API, and runtime.
-
"Keeping Up with the Java Release Train" [I/O]
20 augustus 2026 · 34 min
-
"JSON API, Valhalla Progress, LTS ❤️ PQC" [IJN]
15 augustus 2026 · 10 min
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). Lees meer
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' mail re primitive patterns: https://mail.openjdk.org/archives/list/amber-spec-experts@openjdk.org/thread/WSXW4QMJ3EBIHIULEB25HUAMR5JB767H/
JEP 540: https://openjdk.org/jeps/540
JEP 496: https://openjdk.org/jeps/496
JEP 497: https://openjdk.org/jeps/497
JEP 572: https://openjdk.org/jeps/572
Blog post in PQC in LTS: https://blogs.oracle.com/java/post-quantum-cryptography-in-long-term-support-jdk-releases
Accelerated Vulnerability Detection and Response: https://blogs.oracle.com/security/accelerating-vulnerability-detection-and-response-at-oracle
More frequent Oracle JDK releases: https://blogs.oracle.com/java/transitioning-java-to-more-frequent-security-updates
More Frequent OpenJDK releases: https://mail.openjdk.org/archives/list/jdk-updates-dev@openjdk.org/thread/SVHDNJDY62MX6YBEA4FSMW4U72H77F6S/
JDK 27 RC pushed back: https://mail.openjdk.org/archives/list/jdk-dev@openjdk.org/thread/EYKJPUAZ4BX4DXD7H4C5ETWJFNQZBFO5/
OpenJDK Mail Search: https://openjdk.barlasgarden.com/
-
"Embracing Virtual Threads with Helidon" [I/O]
6 augustus 2026 · 14 min
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. Lees meer
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 happening in the Java ecosystem.
-
"JIT Compiler From the Ground Up" [AtA]
30 juli 2026 · 46 min
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. Lees meer
In this "Ask the Architects" episode of the Inside Java Podcast, recorded during JavaOne 2026, Nicolai Parlog talks to Roberto Lozano, compiler engineer at the Java Platform Group at Oracle.
In our show "Ask the Architects", we talk to experts in OpenJDK about their work on the Java language, API, and runtime.
-
"AI Solutions with Spring AI 2.0 and Java" [I/O]
23 juli 2026 · 20 min
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. Lees meer
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 what's happening in the Java ecosystem.
-
"JDK 27 + Valhalla, Now! + Hackathon" [IJN]
19 juli 2026 · 10 min
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. Lees meer
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 the Wild" hackathon: https://www.hackster.io/contests/modern-java-in-the-wild
AOT vs agents: https://bugs.openjdk.org/browse/JDK-8387190
AOT and JVMTI agents: https://bugs.openjdk.org/browse/JDK-8387194
"Exploiting GPU Tensor Cores": https://openjdk.org/projects/babylon/articles/hat-tensors/hat-tensors
-
"Scripting JS and Python with Project Detroit" with Mikael Vidstedt [AtA]
9 juli 2026 · 16 min
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. Lees meer
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: https://openjdk.org/projects/detroit/
-
"How JEPs Drive Java's Evolution" with Alex Buckley [AtA]
25 juni 2026 · 57 min
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. Lees meer
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.
-
"Java *is* Memory Efficient" with Ron Pressler [AtA]
28 mei 2026 · 35 min
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. Lees meer
In this "Ask the Architect" episode of the Inside Java Podcast, recorded during JavaOne 2026, Nicolai Parlog talks to Ron Pressler, Java Architect at Oracle.
-
"Java Gets Post-Quantum TLS" [IJN]
18 mei 2026 · 5 min
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. Lees meer
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
-
"Make Java Safer with Flexible Constructor Bodies" [IJN]
5 mei 2026 · 7 min
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. Lees meer
Make sure to check https://inside.java/podcast
-
"Ask the Architects at JavaOne'26" [AtA]
23 april 2026 · 58 min
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. Lees meer
Make sure to check https://inside.java/podcast
-
"You Must Avoid Final Field Mutation" [IJN]
16 april 2026 · 10 min
With JDK 26 / JEP 500 starting to prevent final field mutation through reflection, it is important that Java projects stop employing that practice. Lees meer
For more, check https://inside.java/podcast
-
"How JDK 26 Improves G1's Throughput" [AtA]
9 april 2026 · 17 min
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. Lees meer
In this "Ask the Architect" episode of the Inside Java Podcast, recorded during JavaOne 2026, Nicolai Parlog talks to Stefan Johansson, Hotspot Garbage Collection engineer at Oracle.
For more, check https://inside.java/podcast
-
"Analyzing Crashed JVMs" [IJN]
4 april 2026 · 5 min
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. Lees meer
-
"Java Carrier Classes & Discussing Syntax" [AtA]
26 maart 2026 · 46 min
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. Lees meer
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.
-
"Unboxing Java 26 for Developers" [IJN]
12 maart 2026 · 11 min
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. Lees meer
-
"Towards Better Checked Exceptions" [IJN]
9 maart 2026 · 13 min
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. Lees meer
-
"LazyConstants in JDK 26" [IJN]
6 maart 2026 · 10 min
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. Lees meer
-
"HTTP/3 in Java" [ATA]
26 februari 2026 · 43 min
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. Lees meer
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.
-
"Carrier Classes" [IJN]
23 februari 2026 · 10 min
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). Lees meer
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.
-
"Java's Plans for 2026" [IJN]
19 februari 2026 · 9 min
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. Lees meer
-
The New Inside Java Podcast
13 februari 2026 · 5 min
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. Lees meer
-
"Scripting Java, Collections & Generics, BeJUG"
28 januari 2026 · 41 min
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. Lees meer
-
"Predictability or Innovation? Both!" with Georges Saab
22 december 2025 · 21 min
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? Lees meer
Nicolai Parlog discusses these topics with Georges Saab, Senior Vice President of the Java Platform Group and Chair of the OpenJDK Governing Board.
-
"From Sumatra to Panama, from Babylon to Valhalla" with John Rose
2 december 2025 · 53 min
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. Lees meer
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.
-
"From Cowboy Mode to Careful Stewardship" with Mark Reinhold
24 oktober 2025 · 41 min
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. Lees meer
Nicolai Parlog talks to Mark Reinhold, Chief Architect of the Java Platform, who brings nearly three decades of experience shaping Java's evolution.
-
"Amber & Valhalla - Incremental Design and Feature Arcs" with Brian Goetz
24 september 2025 · 21 min
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. Lees meer
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.
-
"Deprecations & Removals" with Stuart Marks
28 juli 2025 · 22 min
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. Lees meer
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.
-
"Integrity by Default" with Ron Pressler
23 juni 2025 · 21 min
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. Lees meer
Nicolai Parlog talks to Ron Pressler, who is Java Architect at Oracle and, among other things, lead of Project Loom.
-
"Efficient Initialization Using Stable Values" with Per Minborg
9 juni 2025 · 29 min
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. Lees meer
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.
-
"Ahead of Time Computation" with Dan Heidinga
16 mei 2025 · 23 min
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. Lees meer
Nicolai Parlog discusses with Dan Heidinga, who is JVM Runtime Architect at Oracle and, among other things, member of projects Leyden and Valhalla.
-
"Stream Gatherers" with Viktor Klang
4 mei 2025 · 33 min
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. Lees meer
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.
-
"Doc, JavaDoc and Markdown" with Jonathan Gibbons
21 januari 2025 · 56 min
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. Lees meer
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.
-
"Inside Java Weekly: JDK 24 and More" with Chad
20 december 2024 · 15 min
In this shorter-format pod, Chad talks about JDK 24, preview features, and more. Lees meer
Show Notes
JEP 11: Incubator Modules
https://openjdk.org/jeps/11JEP 12: Preview Features
https://openjdk.org/jeps/12Using 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/483JEP 485: Stream Gatherers
https://openjdk.org/jeps/485JEP 491: Synchronize Virtual Threads without Pinning
https://openjdk.org/jeps/491JEP 494: Module Import Declarations (Second Preview)
https://openjdk.org/jeps/494JEP 495: Simple Source Files and Instance Main Methods (Fourth Preview)
https://openjdk.org/jeps/495The Foreign Function and Memory API
https://dev.java/learn/ffm/ -
"The Panama Effect" with Jorn Vernee
8 januari 2024 · 23 min
The Foreign Function and Memory API will be finalised in JDK 22. This API helps you integrate native code within your Java program. Lees meer
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" with Stuart Marks
25 april 2023 · 40 min
Sequenced Collections, targeted for JDK 21, are a new collection type created to represent a sequence of elements with a defined encounter order. Lees meer
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: A Look Back and A Look Ahead" with Alex Buckley
21 maart 2023 · 33 min
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. Lees meer
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 & Virtual Threads"
12 januari 2023 · 29 min
Helidon Níma is the first Java microservices framework built from the ground up on virtual threads. Lees meer
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.
-
"Java Language - State of the Union"
23 december 2022 · 34 min
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. Lees meer
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.
-
"JavaFX"
18 november 2022 · 15 min
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.
-
"Java 19 is Here!"
20 september 2022 · 35 min
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. Lees meer
Show notes:
JDK 19
JEP 425 Virtual Threads
JEP 429 Structured Concurrency
Game of Life by Elliot Barlas
Project Loom C5M
-
"JavaOne is Back!"
3 augustus 2022 · 30 min
Chad interviews Sharat Chander about both the history of JavaOne, and what to expect with the return of it in October. Lees meer
Show notes:
Update blog series on Inside.java
Register Now to get Early Pricing