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.{#block-a9c8a1e1-3105-4ea3-80ff-84fea4726402}

To quote my own article:{#block-a9c8a1e1-3105-4ea3-80ff-84fea4726402}

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.{#block-19cdbfac-1c23-4648-af2f-6bd2f85951c2}

Who instruments the instrumenters?

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

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 .

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:

The Inner Workings of Safepoints

Wed, 02 Aug 2023 10:27:27 +0000

A Java thread in the JVM regularly checks whether it should do extra work besides the execution of the bytecode.

This work is done during so-called safepoints. There are two types of safepoints: local and global.

At thread-local safepoints, also known as thread-local handshakes, only the current thread does some work and is therefore blocked from executing the application.
At global safepoints, all Java threads are blocked and do some work. At these safepoints, the state of the thread (thread-local safepoints) or the JVM (global safepoints) is fixed. This allows the JVM to do activities like method deoptimizations or stop-the-world garbage collections, where the amount of concurrency should be limited.

But this article isn’t about what (global) safepoints are. Fr this, please refer to Nitsan Wakart’s and Seetha Wenner’s articles on this topic and for thread-local safepoints, which are a relatively recent addition to JEP 312.

I could write a blog post, or ...

Sat, 15 Jul 2023 07:09:33 +0000

My goal is to write a blog post every two weeks, it’s great to stick to a schedule and force yourself to publish pieces even if they are not perfect.

This doesn’t mean that these blog posts are terrible, just that they could need a bit more polish or could cover a bit more of the topic. But I know many people that have dozens of half-finished blog posts in their pipeline, which aren’t just there and so they don’t publish anything for months.

Debugging OpenJDK Tests in VSCode (Without Losing Your Mind)

Mon, 26 Jun 2023 11:27:55 +0000

Consider you want to debug a test case of the JDK like serviceability/AsyncGetCallTrace . This test, and many others, are implemented using the Regression Test Harness for the JDK (jtreg):

jtreg is the test harness used by the JDK test framework. This framework is intended primarily for regression tests. It can also be used for unit tests, functional tests, and even simple product tests – in other words, just about any type of test except a conformance test, which belong in a TCK.

Johannes Bechberger's Tour d'Europe

Fri, 16 Jun 2023 17:08:53 +0000

Between 31st May and 14th June, I was on tour, giving seven talks in 4 cities in 3 different countries:

31st May: JUG Milano
5th June: OpenValue Munich Meetup
7th June: JDriven Full Stack Conference in Nieuwegein
10th and 11th of June: Gulasch Programmier Nacht Karlsruhe
14th of June: Karlsruher Entwicklertag

A visualization of all the cities I visited, but I took the train for all transits (except for the Arnhem to Nieuwegein route, where Ties van de Ven drove me in his Tesla).

It was an exciting trip, and I had the pleasure of visiting friends in Zurich and Augsburg and a grain mill shop in Munich.

Class Loader Hierarchies

Sat, 03 Jun 2023 08:56:55 +0000

Understanding class loader hierarchies is essential when developing Java agents, especially if these agents are instrumenting code.

In my Instrumenting Java Code to Find and Handle Unused Classes article, I instrumented all classes with an agent and used a Store class in this newly added code:

A challenge here is that all instrumented classes will use the Store. We, therefore, have to put the store onto the bootstrap classpath, making it visible to all classes.

Unlocking Reproducible Profiler Tests

Fri, 19 May 2023 09:02:33 +0000

In my last article, Using Async-Profiler and Jattach Programmatically with AP-Loader , I hinted that I’m currently working on a test library for writing better profiling API tests.

The library is still work-in-progress, but it already allows you to write profiling API tests in plain Java:

private int innerASGCT2() {
 new Tracer().runASGCT().assertTrue(
 Frame.hasMethod(0, "innerASGCT2", "()I"), 
 Frame.hasMethod(1, "testRunASGCT2"));
 return 0;
}

@Test
public void testRunASGCT2() {
 innerASGCT2();
}

This test case checks that calling AsyncGetCallTrace gives the correct result in this specific example. The test library allows you to write tests comparing the returns of multiple GetStackTrace, AsyncGetCallTrace, and AsyncGetStackTrace invocations in different modes and settings. The library can be found as trace-tester on GitHub; I aim to bring it into the OpenJDK later with my JEP.

Using Async-Profiler and Jattach Programmatically with AP-Loader

Thu, 04 May 2023 11:45:20 +0000

Using async-profiler and jattach can be quite a hassle. First, you have to download the proper archive from GitHub for your OS and architecture; then, you have to unpack it and place it somewhere.

It gets worse if you want to embed it into your library, agent, or application. Library developers cannot just use maven dependency but have to create wrapper code and build scripts that deal with packaging the binaries themselves, or worse, they depend on a preinstalled version which they do not control.

Couldn’t we just Use AsyncGetCallTrace in a Separate Thread?

Tue, 25 Apr 2023 05:31:36 +0000

I’m keenly interested in everything related to profiling on the JVM, especially if it is related to AsyncGetCallTrace, this tiny unofficial API that powers most profilers out there, heck, I’m even in the process of adding an improved version to the OpenJDK , AsyncGetStackTrace.

During the discussions on the related JDK enhancement proposal and PRs fixing AsyncGetCallTrace bugs, one thing often arises: Why is AsyncGetCallTrace always called in the signal handler on top of the stack that we want to walk (like in my Writing a Profiler from Scratch series)?
Interaction between the wall-clock sampler thread and the different signal handlers, as currently implemented in async-profiler.

Instrumenting Java Code to Find and Handle Unused Classes

Sat, 08 Apr 2023 13:26:34 +0000

In this article, let’s take a look at writing a Java agent and instrumentation code to find unused classes and dependencies in your project.

Knowing which classes and dependencies are not used in your application can save you from considering the bugs and problems in these dependencies and classes if you remove them.

There a multiple tools out there, for gradle and maven (thanks, Marit), that do this statically or dynamically (like the one described in the paper Coverage-Based Debloating for Java Bytecode, thanks, Wolfram).

Writing a Profiler in 240 Lines of Pure Java

Thu, 30 Mar 2023 07:14:46 +0000

A few months back, I started writing a profiler from scratch, and the code since became the base of my profiler validation tools.

The only problem with this project: I wanted to write a proper non-safepoint-biased profiler from scratch.

This is a noble effort, but it requires lots C/C++/Unix programming which is finicky, and not everyone can read C/C++ code.

For people unfamiliar with safepoint bias: A safepoint is a point in time where the JVM has a known defined state, and all threads have stopped. The JVM itself needs safepoints to do major garbage collections, Class definitions, method deoptimizations, and more. Threads are regularly checking whether they should get into a safepoint, for example, at method entry, exit, or loop backjumps. A profiler that only profiles at a safepoint have an inherent bias because it only includes frames from the locations inside methods where Threads check for a safepoint. The only advantage is that the stack-walking at safepoints is slightly less error-prone, as there are fewer mutations of heap and stack. For more information, consider reading the excellent article Java Safepoint and Async Profiling by Seetha Wenner, the more technical one by JP Bempel , or the classic article Safepoints: Meaning, Side Effects and Overheads by Nitsan Wakart. To conclude: Safepoint-biased profilers don’t give you a holistic view of your application, but can still be helpful to analyze major performance issues where you look at the bigger picture.

Book review - Practical Design Patterns for Java Developers

Fri, 17 Mar 2023 08:27:08 +0000

Hone your software design skills by implementing popular design patterns in Java

This book is for sale on Amazon in Kindle and Paperback editions .

We’ll start this post with the personal verdict of two avid readers of this book:

Frank Delporte’s Verdict

I’ve been programming since I was 10y old, but I graduated from film school as a video editor, so I never learned the “official” way to be a programmer. It was only by following courses and, most importantly, learning from colleagues that I started making “readable and maintainable” code, which is precisely the topic of this book.

Validating Java Profiling APIs

Thu, 16 Mar 2023 14:43:48 +0000

In my last article , I covered a correctness bug in the fundamental Java profiling API AsyncGetCallTrace that I found just by chance.

Now the question is: could we find such bugs automatically?

Potentially uncovering more bugs or being more confident in the absence of errors.

I already wrote code to test the stability of the profiling APIs, testing for the lack of fatal errors, in my jdk-profiling-tester project.

Such tools are invaluable when modifying the API implementation or adding a new API.

Do you trust profilers? I once did too!

Wed, 01 Mar 2023 13:14:06 +0000

Profilers are great tools in your toolbox, like debuggers, when solving problems with your Java application (I’ve been on a podcast on this topic recently).

I’ll tell you some of their problems and a technique to cope with them in this article.

There are many open-source profilers, most notably JFR/JMC, and async-profiler, that help you to find and fix performance problems.

But they are just software themselves, interwoven with a reasonably large project, the OpenJDK (or OpenJ9, for that matter), and thus suffer from the same problems as the typical problems of the applications they are used to profile:

Foojay Podcast #14: Debugging Tools and Skills for Fun and Profit

Mon, 20 Feb 2023 08:29:01 +0000

Let’s talk about debugging and observability.

We work with debugging all the time, but how well do we know this common practice?

Observability, monitoring, and debugging at scale for your production…

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Spotify
Apple Podcasts
And most others…

Guests

A lot of rubber ducks
Johannes Bechberger
- JVM and profiler developer
- Worked on the JDWP protocol and profiling
- https://github.com/parttimenerd
- https://twitter.com/parttimen3rd
- https://mastodon.social/@parttimenerd
- AsyncGetStackTrace: A better Stack Trace API for the JVM
- A short primer on Java debugging internals
Marit van Dijk
- Developer Advocate at JetBrains
- https://maritvandijk.com/
- https://twitter.com/MaritvanDijk77
- https://mastodon.social/@maritvandijk
Ties van de Ven
- Software Engineer @ JDriven, Coach @ Jcore
- https://www.tiesvandeven.nl/
- https://twitter.com/ties_ven
- 6 Steps to help you debug your application

Host

Shai Almog
- Author of “Practical Debugging at Scale ”
- https://debugagent.com/
- https://mastodon.social/@debugagent
- https://twitter.com/debugagent

Producer

Frank Delporte
- https://foojay.social/@frankdelporte
- https://twitter.com/frankdelporte

Content

00'00 Intro and music
00'24 About the topic of this podcast
00'58 Introduction of the guests and host
05'14 Debugging with IntelliJ IDEA and discoverability of tools
- YouTube: Debugger playlist
- YouTube: Profiling tools
- YouTube: Profiling live stream
13'27 JDWP protocol
19'43 Exception breakpoints
- Foojay: Exception Breakpoint that Doesn’t Suck and a Real Use Case for Method Breakpoints
20'34 External debugging tools
- https://rubberduckdebugging.com/
26'55 Observability
37'58 What information should you look for while debugging
45'46 Be aware of tunnel vision while debugging
49'33 What to do if you don’t know where to search for the bug
- https://git-scm.com/docs/git-bisect
- Foojay: External Debugging Tools 2: git bisect
57'05 Outro

JFR Timestamps and System.nanoTime Foojay.io

Wed, 08 Feb 2023 15:33:34 +0000

Did you ever wonder whether JFR timestamps use the same time source as System.nanoTime?

This is important when you have miscellaneous logging besides JFR events; otherwise, you would not be able to match JFR events and your logging properly.

We assume here that you use System.nanoTime and not less-suited timing information from System.currentTimeMillis().

The journey into this started with a question on the JDK Mission Control slack channel, which led me into a rabbit hole:

Using Firefox Profiler beyond the web

Fri, 03 Feb 2023 15:28:55 +0000

This blog post is the base for the second half of my upcoming talk at FOSDEM 2023 on the topic “Firefox Profiler beyond the web: Using Firefox Profiler to view Java profiling data .”

I detailed in my last blog post how the Firefox Profiler can be used to view Java profiling data:

But I’m of course not the only one who uses Firefox Profiler beyond the web because using it has many advantages: You’re essentially getting a prototypical visualization for your data in an afternoon.

Firefox Profiler Beyond the Web: IntelliJ plugin for JFR

Thu, 02 Feb 2023 13:13:17 +0000

This blog post is the base of the first half of my upcoming talk at FOSDEM 2023 on the topic “Firefox Profiler beyond the web: Using Firefox Profiler to view Java profiling data .”

For the impatient: Take a look at my Java JFR Profiler IntelliJ plugin to easily profile your application and view JFR files directly in your IDE.

I got involved in the Firefox Profiler development, spending significant portions of my time at SAP in the last half year on it. It has been an exciting ride. I learned a lot and contributed a few features. So I was essentially developing React code when I wasn’t working on ASGST or other OpenJDK-related tools.

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

Writing a Profiler from Scratch: The Profiling Loop

Thu, 12 Jan 2023 15:26:34 +0000

This is the second post in the series, building a profiler from scratch using AsyncGetCallTrace. Today, we’re covering wall-clock profiling and how to collect the obtain stack traces. If you’re unfamiliar with AsyncGetCallTrace, please check out my previous article in the series here .

Our goal today is to essentially write the primary loop of a profiler and do the following every n milliseconds (where n is our chosen profiling interval):

A Short Primer on Java Debugging Internals

Mon, 02 Jan 2023 08:14:17 +0000

I wanted to write about a small side project—a few months back, I got carried away with understanding how Java debugging works.

The following is an hors d’oeuvre, a small post in between my series on profiling, on the Java Platform Debugging Architecture .

All Java debuggers use the Java Debug Wire Protocol (JDWP) to communicate with the JVM, usually using the Java Debug Interface (JDI) abstraction Layer. The protocol can be used to remote debug, but the JVM and the debugger are commonly on the same machine.

Writing a Profiler from Scratch: Introduction

Wed, 21 Dec 2022 15:26:44 +0000

Async-profiler is undoubtedly one of the most used open-source Java profilers out there.

Its most commonly used feature is sampling a given Java program’s stack traces and visualizing them as a flame graph. I would recommend reading the excellent async-profiler manual by Krzysztof Ślusarski or taking a look at my profiling playlist on YouTube if you’re new to this tool.

After using the async-profiler for a while, you might wonder: How does this tool work? And, of course, if you’re someone like me: Could I write a stripped-down versionto learn how it really works?

JFR Event Collection

Thu, 08 Dec 2022 10:08:52 +0000

Ever wondered what all the JDK Flight Recorder events are, in which JDK versions they are supported, and what examples of an event looks like?

Wonder no more, I created the JFR Event Collection website which contains all this and more.

This site gives you an up-to-date collection of all OpenJDK JFR events for every JDK since 11, giving you the following additional information:

configuration properties
fields with their types and description
examples from a renaissance benchmark run
with which GC this event appears
additional descriptions collected by JFR users

The idea for this website came during the development of my prototypical JFR UI:

AP-Loader: A New Way to Use and Embed async-profiler

Tue, 22 Nov 2022 14:54:35 +0000

Using async-profiler can be quite a hassle.

First, you have to download the right archive from GitHub for your OS and architecture, then you have to unpack it and place it somewhere.

Or you get it from your OS distribution, hoping that it is the current version.

It gets worse if you want to embed it into your library, agent, or application. Library developers cannot just use a Maven dependency but have to create wrapper code and build scripts that deal with packaging the binaries themselves. Or, worse, they depend on a preinstalled version which they do not control.

Java Profiling Overview

Mon, 14 Nov 2022 09:14:25 +0000

When I ask Java developers whether they do profile, the answer is usually “no”.

The few that profiled before usually used VisualVM as a student and maybe JProfiler or YourKit years ago at work.

One of the reasons for this is a lack of available information and thus knowledge for everyday Java developers.

This is a pity as profiling should be a part of the tool belt for every experienced developer (not just for Java). The problem is that most of the open-source profilers are targeted to the OpenJDK developers (or their colleagues), even if they won’t admit it. This can be seen in the lack of entry-level material on this topic and even the little that is out there is distributed across multiple conference websites, blogs, YouTube channels, and Twitter accounts.