Johannes Bechberger on foojay.io - Friends Of OpenJDK

Foojay Podcast #93: Update Your JDK, Read More Code, and Talk to Your Users: Interviews From VoxxedDays Amsterdam

Mon, 13 Apr 2026 06:35:00 +0000

In this episode of the Foojay Podcast, we’re bringing you something special: a full batch of hallway-track conversations recorded live at VoxxedDays Amsterdam.

Fifteen guests, one conference, and one theme that kept coming back, whether we planned it or not: Java has grown up quietly, steadily, and in ways that still surprise people who haven’t looked lately. We talked about migrating between versions, new features in the latest Java releases, authorization done right, AI-assisted coding, cryptography, containers, open-source contributions, GDPR data experiments, and, yes, the things people hate about Java but secretly love.

CAP in the Pocket

Mon, 07 Jul 2025 15:27:26 +0000

Smartphones are more powerful then ever, with processors rivaling old laptops. So let’s try to use them like a laptop to develop web-applications on the go.

Below I’ll show you how to do use run and develop a CAP Java Spring Boot application on your smartphone and how to run VSCode locally to develop and modify it. This, of course, works only on Android phones, as they are a Linux at their core.

A Glance into JFR Class and Method Tagging

Mon, 17 Feb 2025 09:26:02 +0000

Ever wonder how the JDK Flight Recorder (JFR) keeps track of the classes and methods it has collected for stack traces and more?

In this short article, I’ll explore JFR tagging and how it works in the OpenJDK.

The slow Death of the onjcmd Debugger Feature

Sat, 18 Jan 2025 10:47:30 +0000

Almost to the day, one and a quarter years ago, I published my blog post called Level-up your Java Debugging Skills with on-demand Debugging. In this artucle, I wrote about multiple rarely known and rarely used features of the Java debugging agent, including the onjcmd feature.

To quote my own article:

JCmd triggered debugging

There are often cases where the code that you want to debug is executed later in your program’s run or after a specific issue appears. So don’t waste time running the debugging session from the start of your program, but use the onjcmd=y option to tell the JDWP agent to wait with the debugging session till it is triggered via jcmd.

Who instruments the instrumenters?

Thu, 30 May 2024 16:25:45 +0000

Fixing bugs in Spring Boot and Mockito by instrumenting them

Have you ever wondered how libraries like Spring and Mockito modify your code at run-time to implement all their advanced features?

Wouldn’t it be cool to get a peek behind the curtains?

This is the premise of my meta-agent, a Java agent to instrument instrumenters, to get these insights and what this blog post is about.

This article is a collaboration with Mikaël Francoeur, who had the idea for the meta-agent and wrote most of this post. So it’s my first ever post-collaboration. But I start with a short introduction to the agent itself before Mikaël takes over with real-world examples.

Hello eBPF: XDP-based Packet Filter (9)

Mon, 13 May 2024 07:13:38 +0000

Welcome back to my series on ebpf. In the last blog post, we learned how annotation processors can generate C code, simplifying writing eBPF applications.

This week, we’ll use this work together with new support for XDP to create a simple package blocker for eBPF (GitHub):

./run_bpf.sh XDPPacketFilter twitter.com

This blocks all incoming IPv4 packages from twitter.com. We see how it works in this blog post. First, we start with some background on networking and explain what XDP is.

Hello eBPF: Generating C Code (8)

Wed, 24 Apr 2024 13:11:40 +0000

Welcome back to my series on ebpf. In the last article, we learned how toauto-layout struct members and auto-generate BPFStructTypes for annotated Java records. We’re going to extend this work today.

This is a rather short article, but the implementation and fixing all the bugs took far more time then expected.

Generating Struct Definitions

We saw in the last article how powerful Java annotation processing is for generating Java code; this week, we’ll tackle the generation of C code: In the previous article, we still had to write the C struct and map definitions ourselves, but writing

Hello eBPF: Auto Layouting Structs (7)

Sun, 14 Apr 2024 16:19:50 +0000

Welcome back to my series on ebpf. In the last article, we learned how to use ring buffers with libbpf for efficient communication. This week, we’re looking into the memory layout and alignment of structs transferred between the kernel and user-land.

Alignment is essential; it specifies how the compiler layouts the structs and variables and where to put the data in memory. Take, for example, the struct that we defined in the previous article in the RingSample:

To Brussels, Canada and back

Tue, 26 Mar 2024 10:53:11 +0000

Last year was my first year blogging, speaking at conferences, meeting incredible people, and seeing places I’ve never been before.

It was at times quite arduous but at the same time energizing, as you can read in my post Looking back on one year of speaking and blogging. I didn’t want it to be a one-off year, so I dutifully started a new article series on eBPF and applied for conferences…

Hello eBPF: Ring buffers in libbpf (6)

Tue, 19 Mar 2024 17:54:22 +0000

Welcome back to my article series on eBPF. Some weeks ago, I got started in using libbpf instead of libbcc. This week, I show you how to use ring buffers, port the code from Ansil H’s blog post eBPF for Linux Admins: Part IX from C to Java, and add tests to the underlying map implementation.

My libbpf-based implementation advances slower than the bcc-based, as I thoroughly test all added functionality and develop a proper Java API, not just a clone.

Hello eBPF: First steps with libbpf (5)

Thu, 07 Mar 2024 13:51:35 +0000

Welcome back to my blog series on eBPF. Two weeks ago, I showed you how to write your own eBPF application using my hello-ebpf library based on libbcc. This week, I show you why using libbcc is not the best idea and start working with the newer libbpf.

With my current libbcc-based approach, we essentially embed the executed eBPF program into our programs as a string into our applications and compile them on the fly for every run:

Hello eBPF: Tail calls and your first eBPF application (4)

Fri, 23 Feb 2024 08:44:51 +0000

Welcome back to my series on eBPF. Two weeks ago, I showed you how to use perf event buffers to stream data from the eBPF program to the Java application.

This week, we will finish chapter 2 of the Learning eBPF book, learn how to use tail calls and the hello-ebpf project as a library and implement one of the book’s exercises.

We start with function and tail calls:

Function Calls

Regular C programs are divided into functions that call each other; so far in this series, all our eBPF programs consisted of just a single function that calls kernel functions. But can we call other eBPF functions? End of 2017, Daniel Borkman et al. introduced the ability to call other functions defined in eBPF:

Is JDWP's onjcmd feature worth using?

Mon, 12 Feb 2024 11:25:22 +0000

A few months ago, I told you about the onjcmd feature in my blog post Level-up your Java Debugging Skills with on-demand Debugging (which is coming to JavaLand 2024). The short version is that adding onjcmd=y to the list of JDWP options allows you to delay accepting the incoming connection request in the JDWP agent until jcmd <JVM pid> VM.start_java_debugging is called.

The main idea is that the JDWP agent

only listens on the debugging port after it is triggered, which could have some security benefits
and that the JDWP agent causes less overhead while waiting, compared to just accepting connections from the beginning.

The first point is debatable; one can find arguments for and against it. But for the second point, we can run some benchmarks. After renewed discussions, I started benchmarking to conclude whether the onjcmd feature improves on-demand debugging performance. Spoiler alert: It doesn’t.

Hello eBPF: Recording data in event buffers (3)

Fri, 02 Feb 2024 14:45:02 +0000

Welcome back to my article series on eBPF. Last week, I showed you how the eBPF program and Java application can communicate using eBPF maps. This allowed us to write an application that counts the number of execve calls per user.

This week, I’ll show you briefly how to use another kind of eBPF maps, the perf event buffer, and run tests with docker and JUnit 5.

This article is shorter than the previous one as I’m preparing for the OpenJDK committers workshop in Brussels and my Python and Java DevRoom talks at FOSDEM. I’m happy to meet my readers; say hi when you’re there.

Hello eBPF: Recording data in basic eBPF maps (2)

Thu, 18 Jan 2024 15:50:44 +0000

Welcome back to my article series on eBPF.

Last week, I introduced eBPF, the series, and the project and showed how you can write a simple eBPF application with Java that prints “Hello World!” whenever a process calls execve:

public class HelloWorld {
 public static void main(String[] args) {
 try (BPF b = BPF.builder("""
 int hello(void *ctx) {
 bpf_trace_printk("Hello, World!");
 return 0;
 }
 """).build()) {
 var syscall = b.get_syscall_fnname("execve");
 b.attach_kprobe(syscall, "hello");
 b.trace_print();
 }
 }
}

But what if we want to send more information from our eBPF program to our userland application than just some logs?

Hello eBPF: Developing eBPF Apps in Java (1)

Tue, 09 Jan 2024 16:34:56 +0000

eBPF allows you to attach programs directly to hooks in the Linux kernel without loading kernel modules, like hooks for networking or executing programs.

This has historically been used for writing custom package filters in firewalls. Still, nowadays, it is used for monitoring and tracing, becoming an ever more critical building block of modern observability tools. To quote from ebpf.io:

Historically, the operating system has always been an ideal place to implement observability, security, and networking functionality due to the kernel’s privileged ability to oversee and control the entire system. At the same time, an operating system kernel is hard to evolve due to its central role and high requirement towards stability and security. The rate of innovation at the operating system level has thus traditionally been lower compared to functionality implemented outside of the operating system.

Looking Back on One Year of Speaking and Blogging

Fri, 05 Jan 2024 17:49:04 +0000

2023 was an adventurous year for me: I came into my blogging rhythm, blogging every one to two weeks, resulting in 39 articles, many of them on Foojay.io, spoke at my first conferences, around 14 overall, 22 if you include JUGs and online conferences, and continued working on my IntelliJ plugin, as well as my proposal for a new profiling API.

This article is a recollection of the year’s highlights. If you want a complete list of my presentations, visit my Talks page or the Presentations page in the SapMachine Wiki.

Using AI to Create JFR Event Descriptions

Fri, 29 Dec 2023 05:42:16 +0000

JFR (JDK Flight Recorder) is the default profiler for OpenJDK (see my other blog posts for more information).

What makes JFR stand out from the other profilers is the ability to log many, many different events that contain lots of information, like information on class loading, JIT compilation, and garbage collection.

You can see a list of all available events on my JFR Event Collection website:

This website gives an overview of the events, with descriptions from the OpenJDK, their properties, examples, configurations, and the JDK versions in which every event is present. However, few descriptions are available, and the available texts are mostly single sentences.

Writing C Code in Java

Wed, 20 Dec 2023 09:21:56 +0000

The Foreign Function & Memory API (also called Project Panama) has come a long way since it started. You can find the latest version implemented in JDK 21 as a preview feature (use --enable-preview to enable it) which is specified by the JEP 454:

By efficiently invoking foreign functions (i.e., code outside the JVM), and by safely accessing foreign memory (i.e., memory not managed by the JVM), the API enables Java programs to call native libraries and process native data without the brittleness and danger of JNI. JEP 454

Profiling Maven Projects with my IntelliJ Profiler Plugin

Thu, 14 Dec 2023 10:41:34 +0000

Or: I just released version 0.0.11 with a cool new feature that I can’t wait to tell you about…

According to the recent JetBrains survey, most people use Maven as their build system and build Spring Boot applications with Java. Yet my profiling plugin for IntelliJ only supports profiling pure Java run configurations. Configurations where the JVM gets passed the main class to run. This is great for tiny examples where you directly right-click on the main method and profile the whole application using the context menu:

Who Killed the JVM? Attaching a Debugger Twice

Wed, 06 Dec 2023 17:17:47 +0000

A few weeks back, I told you about on-demand debugging in my Level-up your Java Debugging Skills with on-demand Debugging blog post, enabling you to delay a debugging session until:

You gave orders via jcmd (onjcmd=y option), a feature contributed by the SapMachine team
the program threw a specific exception (onthrow=<exception>)
The program threw an uncaught exception (onuncaught=y)

This is quite useful because the JDWP agent has to do substantial initialization before it can start listening for the attaching debugger:

Custom Events in the Blocky World: Using JFR in Minecraft

Tue, 28 Nov 2023 19:12:50 +0000

I was searching for some JFR-related settings on the internet when I stumbled upon the /jfr command that exists in Minecraft:

This, of course, intrigued me, especially as Minecraft apparently adds some custom JFR events:

So I had to check it out. I downloaded and started the Java server, got a demo account, and connected to my local instance. This works with a demo account when you launch the demo world, enable the cheat mode in the settings, kick yourself via “/kick @p,” and then select your own server. I found this via this bug report.

Custom JFR Events: A Short Introduction

Sun, 26 Nov 2023 21:08:03 +0000

JDK Flight Recorder (JFR) is one of the two prominent open-source profilers for the OpenJDK (besides async-profiler).

It offers many features (see Profiling Talks) and the ability to observe lots of information by recording over one hundred different events.

If you want to know more about the existing events, visit my JFR Event Collection website (related blog post):

Besides these built-in events, JFR allows you to implement your events to record custom information directly in your profiling file.

Loom is just HyperThreading in Java

Tue, 14 Nov 2023 10:54:06 +0000

While sitting in Cay Horstmann’s “Looming Changes in Java Concurrency” talk at BaselOne, I had an epiphany: Aren’t virtual threads with Loom just a version of HyperThreading on the JVM?

Both try to utilize a computation resource fully, be it hardware core or platform thread, by multiplexing multiple tasks onto it, despite many tasks waiting regularly for IO operations to complete:

When one task waits, another can be scheduled, improving overall throughput. This works especially well when longer IO operations follow short bursts of computation.

Putting JFR into Context

Thu, 02 Nov 2023 14:03:25 +0000

Have you ever wanted to bring your JFR events into context? Adding information on sessions, user IDs, and more can improve your ability to make sense of all the events in your profile.

Currently, we can only add context by creating custom JFR events, as I presented in my Profiling Talks:

More here: https://mostlynerdless.de/profiling-talks/

We can use these custom events to store away the information and later relate them to all the other events by using the event’s time, duration, and thread. This works out-of-the-box but has one major problem: Relating events is quite fuzzy, as time stamps are not as accurate (see JFR Timestamps and System.nanoTime), and we do all of this in post-processing.

JDWP, onthrow and a mysterious error

Thu, 26 Oct 2023 13:44:01 +0000

In my previous Java-related blog post called Level-up your Java Debugging Skills with on-demand Debugging, I showed you how to use the onthrow option of the JDWP agent to start the debugging session on the first throw of a specific exception.

This gave us a mysterious error in JDB:

And I asked if somebody had any ideas. No one had, but I was at Devoxx Belgium and happened to talk with Aleksey Shipilev about it at the Corretto booth: Two OpenJDK developers having fun at Devoxx: Investigating a jdb bug with Shipilev
in the Coretto booth (Tweet)

Level-up your Java Debugging Skills with on-demand Debugging

Mon, 16 Oct 2023 14:21:24 +0000

Debugging is one of the most common tasks in software development, so one would assume that all features of debuggers have ample coverage in tutorials and guides.

Yet there are three hidden gems of the Java Debugging (JDWP) agent that allow you to delay the start of the debugging session until…

you gave orders via jcmd (onjcmd=y option)
the program threw a specific exception (onthrow=<exception>)
the program threw an uncaught exception (onuncaught=y)

Before I tell you more about the specific options, I want to start with the basics of how to apply them.

Report of My Trip to JavaZone and Northern Germany

Mon, 02 Oct 2023 08:44:28 +0000

Between 2nd and 17th September, I gave three talks in three different cities:

JavaZone Oslo, 7th September: Unleash the Power Of Open-Source Profilers (InfoQ article)
Java Forum Nord Hannover, 12th September: Unleash the power of Open-Source Java Profilers
code.talks Hamburg, 14th September: Writing a Java Profiler in Pure Java (blog post)

I traveled from Karlsruhe to Oslo (via Stuttgart Airport) and from Oslo to Hanover via plane, then to Hamburg, Hanover, back to Hamburg, and the end via Bonn back to Karlsruhe via train:

C2 Might Be Slowing Down Your Builds

Thu, 28 Sep 2023 09:55:13 +0000

At the JavaForumNord two weeks ago, I had a friendly chat with Karl Heinz Marbaise (Chairman of the Apache Maven Project), where he mentioned that he wanted to start profiling Maven. This sounded interesting, so I started looking into the performance and bottlenecks of Maven. I began by using the Maven build of maven itself as a starting point (excluding the tests). The following is my first observation related to Maven builds in CIs.

Taming the Bias: Unbiased Safepoint-Based Stack Walking

Thu, 17 Aug 2023 14:00:34 +0000

Walking only at safepoints has advantages. The main one is that you aren’t walking the stack in a signal handler but synchronously to the executed program. Therefore you can allocate memory, acquire locks and rematerialize virtual thread / Loom frames. The latter is significant because virtual threads are the new Java feature that cannot support using signal-handler-based APIs like AsyncGetCallTrace.

This article is based on the ideas of Erik Österlund, and the second one is related to these new ideas. The first one is AsyncGetCallTrace Reworked: Frame by Frame with an Iterative Touch!, which you should read before continuing with this post. For a refresher on safepoints, please read The Inner Workings of Safepoints.