Inside Java

JDK 28's adaptive heap sizing for ZGC dynamically balances CPU use and memory consumption with close-to-zero configuration. Value classes introduce new challenges for conversions between custom numeric types, which type classes could eventually address, but unresolved questions about how these features should interact mean that primitive patterns won't return in JDK 28 and will instead be withdrawn. 😟 Other highlights are upcoming Java events and JDK 28's planned features.
Links:
Adaptive heap sizing for ZGC:
JEP 546 - Adaptive Heap Sizing for ZGC: https://openjdk.org/jeps/546
Java events:
FOSDEM: https://wiki.debian.org/Java/DevJam/2027/Fosdem
JVMLS: https://openjdk.org/projects/mlvm/jvmlangsummit/
JavaOne tickets: https://www.oracle.com/javaone/register/
Value classes, numeric conversions, primitive patterns:
JLS on conversions: https://docs.oracle.com/en/java/javase/27/docs/specs/jls/jls-5.html
Brian Goetz on type classes: https://www.youtube.com/watch?v=Gz7Or9C0TpM
Amber mail on primitive patterns: https://mail.openjdk.org/archives/list/amber-spec-experts@openjdk.org/thread/UYEK3PGOHN6R56AHJTSLPGAY363K666S/
Amber mail on constant patterns: https://mail.openjdk.org/pipermail/amber-spec-experts/2026-January/004306.html
JDK 28:
early-access builds: https://jdk.java.net/28/
feature list: http://openjdk.org/projects/jdk/28/

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.

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

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

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