Inside Java – Détails, épisodes et analyse

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.

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.