JEPs on foojay.io - Friends Of OpenJDK

Why Every JVM In Your Fleet Warms Up Alone

Thu, 01 Oct 2026 00:00:00 +0000

We live in a distributed systems world. We handle more traffic “simply” by adding more instances, or replicas, of the same service and then distribute the traffic between them.

The service ends up running on tens, hundreds or thousands of JVMs. Same JAR, same JDK, same instance type, same traffic shape. Instance 1 starts cold, spends its first minutes working out which of its several thousand methods are hot, and compiles them optimizing them specifically for the traffic observed. Instance 1000, starting a couple hours later, does exactly the same thing. From scratch, for the 1000th time.

Hello Java 27! Have You Been Working Out?

Tue, 15 Sep 2026 08:00:00 +0000

It’s been six months since we saw a new Java release, and this new edition seems to be ready to flex its muscles. With numerous improvements to performance and security, Java 27 is like that friend that you haven’t seen all summer, and when you finally see them again it’s clear that they spent a lot of time in the gym!

This post focuses on everything that has been added in this release, giving you a brief introduction to each of the features. Where applicable the differences with Java 26 are highlighted and a few typical use cases are provided, so that you’ll be more than ready to start using these features after reading this.

Your TLS Stack Is Lying to You About Zero-Copy

Wed, 10 Jun 2026 12:00:28 +0000

The “No Waste Compute” Constraint

When I started designing the Exeris Kernel, I set one non-negotiable rule very early: no waste compute. That rule sounds like a performance slogan until it starts killing otherwise normal design decisions.

I had already banned ThreadLocal, moved context propagation to Scoped Values, and pushed more of the runtime into explicit off-heap ownership. The idea was simple: if the hot path is supposed to stay outside GC pressure, then memory shape and lifetime cannot be treated as incidental details.

Scoped Values: Why I Banned ThreadLocal in Exeris

Thu, 28 May 2026 09:36:00 +0000

In a zero-copy runtime designed for 1-VT-per-Stream density, ThreadLocal is a performance serial killer. Here is the forensic analysis and how JEP 506 Scoped Values changed everything.

When I started designing the Exeris Kernel — a next-generation, zero-copy runtime built for Java 26+ — I established one non-negotiable architectural law: “No Waste Compute.”

In a system designed to handle extreme density by mapping exactly one Virtual Thread to every network stream (1-VT-per-Stream), every byte of memory and every CPU cycle must be intentional.

How to Use Java as a Scripting Language

Mon, 23 Mar 2026 10:00:19 +0000

The Scripting Dilemma

If you’re like me, as a Java developer, you struggle to remember bash or python syntax for quick scripts.

You end up “vibe coding” it, then struggle again when you need to adapt it. If only you could write it in Java!

You might say “Java is not for scripting” and “I don’t want maven or Gradle”.Modern Java has quietly eliminated the traditional barriers that made it unsuitable for scripting.With instant execution, shebang support, and zero-setup automation, Java has evolved into a lean scripting language. Write precise, maintainable code without the “vibe coding” that comes with unfamiliar languages.

How is Leyden improving Java Performance? Part 1 of 3

Tue, 17 Mar 2026 12:00:45 +0000

In this series of 3 blog posts we will explain how OpenJDK project Leyden is helping to improve a specific area of performance where Java has notably lagged behind other languages i.e. application ‘startup’, ‘warmup’, and ‘initial footprint’.

Part 1 explains what those terms mean and why Java faces challenges in matching the behaviour of other languages. It then provides an overview of what Leyden has done to improve startup and warmup in existing JDK releases and what is planned for upcoming releases.

Java 26: What’s New?

Tue, 03 Mar 2026 10:00:28 +0000

This article was first published in my personal blog: Java 26: What’s new? and is part of a serie on what’s new on the last versions of Java).

Now that Java 26 is features complete (Rampdown Phase Two at the day of writing), it’s time to walk through all the functionalities that bring to us, developers, this new version.

After Java 25 and its 18 JEPs, Java 26 arrives with a small number of JEPs, 10, with very few new features.

Gotta Code 'Em All: How Java Evolved Beyond Verbosity – Celebrating 30 Years of Pokémon

Fri, 27 Feb 2026 09:57:35 +0000

Happy 30th Anniversary to Pokémon! 🎉

February 27, 2026 marks exactly 30 years since the original Pokémon Red and Green launched in Japan on February 27, 1996. From catching your first Pokémon in Pallet Town to becoming Champion in the Indigo League, the franchise has spent three decades teaching millions of players about strategy, friendship, exploration, and constant improvement, evolving creatures, teams, and even entire generations of games.

Pokémon is literally all about evolution and that same spirit of evolution perfectly matches what’s happening in Java right now.

Project Panama for Newbies (Part 2)

Fri, 02 Jan 2026 01:21:00 +0000

Updated December 29, 2025 (originally published August 17, 2021, republished January 2, 2026): This article now features Java 25 and the Foreign Function & Memory (FFM) API, which has been a standard feature since JDK 22 (JEP-454).

Introduction

Welcome back to Part 2 of Project Panama for Newbies! If you are new to this series, check out Part 1 first.

If you remember from Part 1, we learned how to create C language strings, primitive data types and arrays. We also got a chance to iterate through the data outside of the Java heap and later display items via C’s printf() and Java’s printf() method from the IO.printf().

Project Panama for Newbies (Part 1)

Thu, 01 Jan 2026 09:11:00 +0000

Updated December 28, 2025 (originally published August 10, 2021, republished January 1, 2026): This article now features Java 25 and the Foreign Function & Memory (FFM) API, which has been a standard feature since JDK 22.

Introduction

In this series of articles, we will explore the APIs from OpenJDK’s Project Panama. My intent is to show you how to be proficient in using the Foreign Function and Memory Access APIs as it relates to Java interoperability with native code. After FFI (foreign function interface) & FFM (foreign function memory) have been finalized in JDK 22 the APIs currently reside in the following package namespaces.

Java 25: What's New?

Wed, 03 Dec 2025 09:02:49 +0000

This article was first published in my personal blog: Java 25: What’s new? and is part of a serie on what’s new on the last versions of Java.

Now that Java 25 is out, it’s time to walk through all the functionalities that bring to us, developers, this new version.

Java 25 is the new Long-Term Support (LTS) version, containing no less than 18 JEPs. Even if this isn’t as good as the 24 JEPs in Java 24, it’s still a pretty significant number. No big news on the program, but a number of nice little ones anyway.

Java 24: What's New?

Wed, 26 Feb 2025 09:58:53 +0000

Java 24 will be available soon, on March 18th. What are all the functionalities that this version brings to us as developers?

Java 24 contains not less than 24 JEPs, a record and above all an eponymous figure!

JEP 404: Generational Shenandoah (Experimental)

Shenandoah is a Garbage Collector (GC) originally developed by RedHat and included in OpenJDK. It reduces GC pause times by performing evacuation work concurrently to application threads.

Foojay Podcast #63: How do we keep your Java applications up to date and secure?

Mon, 16 Dec 2024 12:41:10 +0000

Last month, I published a Foojay article about the risks in systems that are stuck on old or outdated Java versions and got a lot of feedback from developers. Most of them want to move on but get stuck on management decisions, outdated production environments, or one of the many other reasons that keep systems stuck on old Java versions and dependencies.

Do you want to bring your system from Java 8 to 23? Did you know that Java 17 already has 13 security releases? And that you can use tools like OpenRewrite to help you update your code?

Builder Pattern Simplicity with JEP-455 Primitive Types

Thu, 10 Oct 2024 10:54:08 +0000

The runtime initiation of any program requires allocating a given memory and after many additional steps the first object could be created.

In a previous post, we explored how to improve maintainability of complex creation processes by using the factory creational pattern[4] and JEP-482, flexible constructor bodies.

The factory design may be a good fit for many cases but it may also create obstacles due to the pattern code centralized nature.

Null object pattern to avoid null pointer exception with JEP-455

Fri, 04 Oct 2024 06:19:18 +0000

The newest release JDK 23 [2] comes with a neat extension to pattern matching for switch and instanceof statements, JEP-455: Primitive Types in Patterns, instanceof and switch [1]. While the introduction of pattern matching can be considered a crucial element in moving the Java platform into a functional paradigm, it introduced several limitations.

Using reference object types or objects only for switch and instanceof statements slightly reduced the possibilities of its utilization. This has had an impact on its use in building code based on design patterns, including refactoring.

JDK 23: Factory Pattern with Flexible Constructor Bodies

Wed, 25 Sep 2024 11:14:01 +0000

Since the introduction of the new JDK release cadence, we have seen an incredible amount of new enhancements added to each JDK cycle, kicking the Java platform back on track compared to other languages.

Source code maintainability plays a very important role as complexity of nowadays projects increases. Yes, design patterns, spelled forward and backward many times, but forgotten at the same time due to various reasons.

Let’s take a look at one particular brand new preview feature added to the latest JDK release 23 [2], JEP-482: Flexible Constructor Bodies [1] in its second iteration.

Java 23 Has Arrived, And It Brings a Truckload of Changes

Tue, 17 Sep 2024 06:45:11 +0000

Java 23 has arrived! It’s been six months since Java 22 was released, so it’s time for a fresh truckload of JEPs.

In this article, we take you on a tour of everything that is part of this release, giving you a brief introduction to each of them.

Where applicable the differences with Java 22 are highlighted and a few typical use cases are provided, so that you’ll be more than ready to start using these features after reading this.

Java 23: What’s New?

Wed, 04 Sep 2024 09:19:35 +0000

As soon as Java 23 is out, it’ll be time to walk through all the functionalities that this version bring to us as developers.

First of all, something has happened that, to my knowledge, has never happened before in a Java release: a preview feature has been removed! The String Templates feature, which appeared as a preview feature in Java 21, has been removed. A global redesign of this feature will be carried out, as it had given rise to much debate and didn’t seem to meet the community’s expectations.

Exploring New Features in JDK 23: Simplifying Java with Module Import Declarations with JEP 476

Thu, 20 Jun 2024 16:14:08 +0000

As Java evolves, simplifying code and improving developer productivity remain priorities.

JEP 476 introduces a new feature in JDK 23: Module Import Declarations.

This feature aims to streamline the process of importing multiple packages from a module, enhancing code readability and reducing boilerplate.

What is JEP 476?

JEP 476 proposes the ability to import all packages exported by a module with a single declaration. This is particularly useful for developers who frequently use multiple packages from the same module, as it eliminates the need for numerous individual import statements.

JUG Munich hosts the JCP Executive Committee meeting to 25th anniversary of JCP

Sun, 14 Apr 2024 19:40:41 +0000

The Java Community Process (JCP) was established in 1998 to formalize the development process of the Java platform, where all interested parties can openly participate in the development of specification standards.

For many reasons, the JCP process [1] has decided to organize at least two face-to-face meetings of the Java Executive Committee per year. These meetings not only contain a very warm exchange of ideas, but are also very helpful in identifying future challenges. These meetings bring executives from all interested parties very close to the Java Community, as their feedback is very important to future platform development.

Java 22: What’s New?

Mon, 18 Mar 2024 14:10:04 +0000

As soon as Java 22 is out, it’ll be time to walk through all the functionalities that this version bring to us as developers.

JEP 461 - Stream Gatherers (Preview)

Enhances the Stream API with support for custom intermediate operations. This is a preview API.

The Stream API provides a fixed set of intermediate and terminal operations. It allows terminal operations to be extended via the Stream::collect(Collector) method, but does not allow intermediate operations to be extended. Some operations are missing or others are possible via a set of operations or via an operation that doesn’t fully match what’s needed.

Foojay Podcast #45: Welcome to Java 22

Mon, 18 Mar 2024 10:31:53 +0000

Last September, we got Java 21, a Long Term Support (LTS) version with eight new big features and seven incubator or preview features.

Does Java 22 also bring that much innovation, or is it just a bug-fix release?

And what needs to be done to get such a release published on time? Let’s find out…

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Revolutionising Java Collections: The Advent of Sequenced Collections in Java 21

Tue, 26 Dec 2023 14:07:42 +0000

Java has been a staple in the software development world for decades, renowned for its robustness and vast ecosystem. However, some seasoned Java developers have encountered limitations within its collections framework, particularly when dealing with ordered elements.

Enter JEP 431. JEP 431, part of the Java Enhancement Proposal system, represents a significant advancement in Java’s ongoing evolution.

The Java Enhancement Proposal system is a process for proposing, reviewing, and implementing new features in the Java programming language.

Java 21 - JEP 445 - Unnamed Classes and Instance Main Methods

Wed, 25 Oct 2023 09:25:48 +0000

Java 21, released on September 19th, 2023, brings many new features, 8 which are fully integrated and 7 which are incubator or preview.

In this article, I want to highlight one of those preview features: Java Enhancement Proposal (JEP) 445: “Unnamed Classes and Instance Main Methods”.

It’s a preview feature, meaning you need extra flags to use it. The goal of JEP 445 is to make it easier to get started with Java, as it’s all about reducing the number of keywords when you write, for instance, your very first HelloWorld Java code.

AsyncGetCallTrace Reworked: Frame by Frame Iterative Touch!

Thu, 10 Aug 2023 09:43:33 +0000

AsyncGetCallTrace is an API to obtain the top n Java frames of a thread asynchronously in a signal handler.

This API is widely used but has its problems, see JEP 435 and my various articles on Foojay.io.

My original approach with my JEP proposal was to build a replacement of the API, which could be used as a drop-in for AsyncGetCallTrace. Still a single method that populates a preallocated frame list:

Hidden and Not-So-Hidden Gems In Java 20

Wed, 03 May 2023 14:32:45 +0000

Let’s see the preview and incubator JEPs in Java 20, as well as many smaller enhancements, bug fixes, and deprecations.

March 2023 marked the latest feature release of the Java platform, which was delivered on time through the six-month release cadence as Java 20. Like Java 19, which became generally available in September 2022, Java 20 targeted JEPs—seven, in this case—from the Panama, Amber, and Loom projects.

I am using the Java 20 jshell tool to demonstrate the code in this article. To follow along, download JDK 20, fire up your terminal, check your version, and run jshell. Note that you might see a newer version of the JDK; that’s okay.

It's Java 20 Release Day! Here's What's New

Tue, 21 Mar 2023 06:40:34 +0000

This will be a good day, because it’s Java 20 release day!

It’s been six months since Java 19 was released, and so it’s time for another fresh wave of Java features.

In this article, we will take you on a tour through all JEPs that come with this release and give you a brief introduction of each one of them.

Where applicable the differences with Java 19 are highlighted and a few typical use cases are provided, so that you’ll be more than ready to use these features after you’ve finished reading!

An Introduction to Scoped Values in Java

Mon, 20 Feb 2023 11:32:20 +0000

After moving to the six-month release cadence, the Java language has entered a rapid development process.

While the process introduces many new features, these new features sometimes cause updates to existing APIs and sometimes result in the development of new APIs.

An example of the second is Scoped Values which has been included in the JDK since Java 20 as an incubator API.

Why were Scoped Values proposed?

Virtual threads became a part of JDK as a preview feature in Java 19.

Java Sealed Classes: Building Robust and Secure Applications

Mon, 20 Feb 2023 11:11:07 +0000

Java sealed classes were introduced in Java 15 as a way to restrict the inheritance hierarchy of a class or interface.

A sealed class or interface restricts the set of classes that can implement or extend it, which can help prevent bugs and make code more maintainable.

Suppose you’re building an e-commerce application that supports different payment methods, such as credit cards, PayPal, and Bitcoin. You could define a sealed class called PaymentMethod that permits various subclasses for each payment method:

AsyncGetStackTrace: A better Stack Trace API for the JVM

Thu, 26 Jan 2023 09:16:06 +0000

This article is the basis for my upcoming talk at FOSDEM 2023,“AsyncGetStackTrace: The Improved Version Of AsyncGetCallTrace (JEP 435),” and is based on JEP Candidate 435.

Consider you want to write a profiler to profile Java applications. Why? Because you think that the existing ones "[…] Are Fucking Terrible" or "[…] Broken". Or you want to start a blog series on writing a profiler from scratch to learn their inner workings (hi there,**regular readers).