app_store_button

google_play_button

Device Banner Block-copy 894x1036

Astu lugude lõputusse maailma

Loe ja kuula

David Delabassee

Inside Java

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

"Java Gets Post-Quantum TLS" [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

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

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

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

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

"You Must Avoid Final Field Mutation" [IJN]

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 Parlog talks to Stefan Johansson, Hotspot Garbage Collection engineer at Oracle.
 
For more, check https://inside.java/podcast

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

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.

"Analyzing Crashed JVMs" [IJN]

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.

"Java Carrier Classes & Discussing Syntax" [AtA]

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.

"Unboxing Java 26 for Developers" [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.

"Towards Better Checked Exceptions" [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.

"LazyConstants in JDK 26" [IJN]

Chad Arimura discusses Project Loom with Ron Pressler.
 
Relevant links:
 
 https://wiki.openjdk.java.net/display/loom/Main https://inside.java/tag/loom https://github.com/openjdk/loom 
For all episodes and more, check out Inside Java and follow @java on Twitter.
 
Episodes are now available on YouTube as well.

"Project Loom" with Ron Pressler

Loe ja kuula

Muud podcastid, mis võivad sulle meeldida ...