Java News
Intelligent JVM Monitoring: Combining JDK Flight Recorder with AIJFR simplifies troubleshooting and profiling by capturing detailed JVM event data—and with the JFR Streaming API, you can access those insights in real time. But what if you could go further and stream live JFR data straight into an AI system to enhance monitoring, accelerate troubleshooting, and even help prevent issues before they occur? In this session, we’ll demonstrate how to use JFR with the latest JDK features to build self-improving applications with the help of AI.
Read MoreJDK 26 G1/Parallel/Serial GC changes
The OpenJDK project is about to release JDK 26 in a few days. This is a good opportunity to add information about notable changes to the stop-the-world collectors in the Hotspot VM.
Read MoreData Oriented Programming, Beyond Records
We've had some good discussions here, and I've got some updates to the ideas outlined in the previous snapshot. There's a lot here, including a lot that I'm identifying as likely future directions but which should not be the topic of current discussion; I want to focus on the highest-priority aspects first...
Read MoreEpisode 48 “HTTP/3 in Java 26” [AtA]
HTTP/3 is the next version of the internet's most important application layer protocol. In this Inside Java Podcast episode, Nicolai Parlog talks to Daniel Fuchs and Daniel Jelinski about HTTP/3's integration into Java's HTTP client.
Read MoreDissecting the CPU-Memory Relationship in Garbage Collection
This article analyzes why we need to look beyond GC pauses to enable maximal infrastructure efficiency and introduces the new Java API for GC CPU in OpenJDK 26. These capabilities empower engineers and researchers to quantify the collector's CPU overhead, providing the data necessary to make informed decisions regarding the memory-CPU trade-off.
Read MoreEpisode 47 “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...
Read MoreJava Serialization: Spooky Action at a Distance - Stack Walker #7
Serialization has been a part of the Java Platform since the 1.1 release. While serialization brings with it a lot of utility and was key in Java's early success, it does have some pretty significant issues as well. In this episode of Stack Walker, we review the history of serialization, the concerns it was attempting to address, and how some of those design decisions have resulted in more than a few headaches for JDK engineers and Java developers alike. We will then look at how the JDK engineering team is working towards addressing the issues that serialization presents and ultimately a replacement.
Read MoreEpisode 46 “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.
Read MoreTowards Better Checked Exceptions - Inside Java Newscast #107
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.
Read MorePost-Quantum Hybrid Key Exchange for TLS 1.3
JEP 527 is now integrated into JDK 27! This feature enhances the security of Java applications by implementing hybrid key exchange algorithms for TLS 1.3. By combining quantum-resistant ML-KEM with traditional elliptic-curve algorithms, the JDK implementation of TLS 1.3 is protected against 'harvest now, decrypt later' threats.
Read MoreSourced from https://inside.java via RSS.