Debugging on foojay.io - Friends of OpenJDK

AI-Assisted Unused & Dead Code Removal

Sun, 28 Jun 2026 07:19:42 +0000

Why Your Codebase Is Forcing AI to Underperform, and What to Do About It

Your AI coding assistant is only as good as the codebase it works on. If your Java application carries years of dead & unused code, and most do, the AI spends its reasoning budget on code that nobody runs. The result is more hallucinations, worse suggestions, and higher token costs. Here’s what to do about it.

Enabling AI Agents to Use a Real Debugger Instead of Logging

Mon, 16 Feb 2026 21:12:13 +0000

Every Java developer has been there. Something breaks, and the first instinct is to litter the code with System.out.println(">>> HERE 1"). Then HERE 2. Then HERE 3 --- value is: " + x. Rebuild. Rerun. Stare at the console. Repeat.

We’ve been doing this for decades. And now, so have our AI agents.

When you ask an AI coding assistant to debug a Java application, it almost always reaches for the same playbook: add logging statements, recompile, rerun, read the output, and reason about what happened. It’s the println debugging loop, automated — but it’s still println debugging.

Unikernel: Profiling and Troubleshooting JVM on Nanos Unikernel

Wed, 11 Feb 2026 13:50:41 +0000

Profiling a Java Application Running Inside an Unikernel with JProfiler

Unikernels are often associated with minimalism and tight resource control.

But can we profile a Java application running inside a unikernel using a standard JVM profiler?

The answer is yes.

In this guide, we will walk step by step through profiling a Quarkus

application running inside a Nanos unikernel using JProfiler and
IBM Semeru JRE 25 (OpenJ9).

No special hacks. Just standard JVM tooling.

The Art of Performance Tuning: Why Saving 30% in the Cloud Means Nothing if Your Code Wastes 1000× More

Tue, 25 Nov 2025 06:46:00 +0000

The Hidden Cost of “Good Enough” Code

A few weeks ago, Kirk Pepperdine published a fascinating performance challenge — a small Java code snippet that appeared trivial but produced puzzling runtime behavior.

He invited readers to take a shot at solving it. If you haven’t seen it yet, stop here for a moment and try it yourself — and when you’re done, check his Kirk’s official solution

When I saw it, I thought it would be a fun exercise to revisit some fundamentals — but the deeper I went, the more I realized it wasn’t just about performance. It was about how we think.

Spring AI Debugging + How to Contribute to Open Source

Wed, 02 Apr 2025 05:56:01 +0000

In this episode, I continue my journey with vector databases, integrating Pinecone , Neo4J , and Spring AI . While making some progress, I also encountered hurdles, such as evolving APIs and the unique architecture of vector stores.

Next, I share insights from an article on contributing to open-source source projects , how it can accelerate your career and enhance both your technical and soft skills. From picking the right project to building credibility within the community, it’s a series of steps that gets better with time and practice!

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}

Front End Debugging Part 2: Console.log() to the Max

Tue, 03 Dec 2024 16:28:40 +0000

Understanding Front-End Logging vs. Back-End Logging
Leveraging Console Log Levels
Customizing Console Output with CSS
Stack Tracing with console.trace()
Assertions for Design-by-Contract
Printing Tables for Clearer Data Visualization
Copying Objects to the Clipboard
Inspecting with console.dir() and dirxml()
Counting Function Calls
Organizing Logs with Groups
Chrome-Specific Debugging Features
Final Word

In my previous article , I talked about why Console.log() isn’t the most effective debugging tool. In this installment, we will do a bit of an about-face and discuss the ways in which Console.log() is fantastic. Let’s break down some essential concepts and practices that can make your debugging life much easier and more productive.

Front End Debugging Part 1: Not just Console Log

Tue, 05 Nov 2024 14:01:45 +0000

Instant Debugging with the debugger Keyword
Triggering Debugging from the Console
DOM Breakpoints: Monitoring DOM Changes
XHR Breakpoints: Uncovering Hidden Network Calls
Simulating Environments for Debugging
Debugging Layout and Style Issues
- Final Word

As a Java developer, most of my focus is on the backend side of debugging. Front-end debugging poses different challenges and has sophisticated tools of its own. Unfortunately, print-based debugging has become the norm in front-end. To be fair, it makes more sense there as the cycles are different and the problem is always a single user problem. But even if you choose to use Console.log, there’s a lot of nuance to pick up there.

The Art of Full Stack Debugging

Fri, 25 Oct 2024 07:24:06 +0000

Full Stack Development, A Shifting Definition
- The Full Stack Debugging Approach
Frontend Debugging: Tools and Techniques
Debugging Across Layers
Conclusion

Full stack development is often likened to an intricate balancing act, where developers are expected to juggle multiple responsibilities across the frontend, backend, database, and beyond. As the definition of full stack development continues to evolve, so too does the approach to debugging.

Full stack debugging is an essential skill for developers, as it involves tracking issues through multiple layers of an application, often navigating domains where one’s knowledge may only be cursory. In this blog post I aim to explore the nuances of full stack debugging, offering practical tips and insights for developers navigating the complex web of modern software development.

Profile IntelliJ IDEA with its own profiler

Wed, 16 Oct 2024 15:49:38 +0000

Other languages: Español 한국어 Português 中文

Just like my previous post , this one is going to be slightly meta. Obviously, you can use IntelliJ IDEA to profile another process , but did you know IntelliJ IDEA can profile itself?

This might be useful if you are writing an IntelliJ IDEA plugin and need to address issues related to your plugin’s performance.

Also, regardless of whether you are a plugin author, the described case might be interesting to you because the profiling strategy that I’ll cover is not exclusive to IntelliJ IDEA – you can use it to troubleshoot similar bottlenecks in other types of projects and using other tools.

Foojay Podcast #58: How Java Developers Can Secure Their Code

Mon, 30 Sep 2024 07:43:46 +0000

Three years after Log4Shell caused a significant security issue, we still struggle with insecure dependencies and injection problems.

In this podcast, we’ll discuss how developers can secure their code.

I talked with three authors who posted a security and code quality post on Foojay.io.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Trash Pandas Love Enterprise Java Garbage Code

Tue, 13 Aug 2024 08:16:55 +0000

If raccoons were software engineers, they would feel at home inside many enterprise systems. These systems are often full of unused and dead code that was written, fully tested, then altered in a way that prevents teams from ever running it.

This garbage code — a raccoon’s favorite — is a maintenance burden that developers must work around to keep passing tests while other major changes are made. This code often doesn’t end up in the trash because it’s hard to know what can be safely removed without breaking the application. But you can better identify bad code if you understand how to look for it.

Allocation Profiling in Java

Fri, 09 Aug 2024 08:44:59 +0000

Read in other languages : 中文 Español Português

We often find ourselves in situations when code is not working properly, and we have no idea where to even begin investigating.

Can’t we just stare at the code until the solution eventually comes to us? Sure, but this method probably won’t work without deep knowledge of the project and a lot of mental effort. A smarter approach would be to use the tools you have at hand. They can point you in the right direction.

Failure is Required: Understanding Fail-Safe & Fail-Fast Strategies

Tue, 30 Jul 2024 08:08:33 +0000

Fail-Fast
Fail-Safe
Choosing Between Fail-Fast and Fail-Safe
Redefining Failure
- Data Corruption
- Don’t Fix the Bug
Debugging Failure
- Avoiding Cascading Failure
Hybrid in Production
Final Word

Failures in software systems are inevitable. How these failures are handled can significantly impact system performance, reliability, and the business’s bottom line.

In this article, I want to discuss the upside of failure. Why you should seek failure, why failure is good and why avoiding failure can reduce the reliability of your application. We will start with the discussion of fail-fast vs. fail-safe, this will take us to the second discussion about failures in general.

Mastering Serverless Debugging

Mon, 29 Jul 2024 10:14:26 +0000

Introduction to Serverless Computing
Challenges of Serverless Debugging
Effective Strategies for Serverless Debugging
Debugging a Lambda Application Locally with AWS SAM
Final Word

Serverless computing has emerged as a transformative approach to deploying and managing applications. The theory is that by abstracting away the underlying infrastructure, developers can focus solely on writing code.

Wireshark & tcpdump: A Debugging Power Couple

Mon, 08 Jul 2024 14:51:05 +0000

Introduction to Wireshark
- Browser Network Monitors
Installation and Getting Started
Navigating Through Noise with Filters
Deep Dive into Data Analysis
Beyond Basic Usage
- The Basics of HTTPS Encryption
- Methods for Decrypting HTTPS in Wireshark
  - Pre-Master Secret Key Logging
  - Using a Proxy
Integrating tcpdump with Wireshark for Enhanced Network Analysis
The Role of tcpdump in Network Troubleshooting
Final Word

Wireshark, the free open-source packet sniffer and network protocol analyzer, has cemented itself as an indispensable tool in network troubleshooting, analysis, and security (on both sides).

Hack a Java application with the debugger

Thu, 13 Jun 2024 04:58:03 +0000

Read in other languages: 中文 Español Português

Back in the day, computer games were different. Not only have graphics and mechanics evolved since, but there’s also one characteristic that doesn’t seem very common in games today: nearly all of them had cheat codes.

Cheat codes were sequences of keys that would give you something extraordinary, such as infinite ammo or the ability to walk through walls. The most common and powerful of them was ‘god mode’ – it made you invincible.

Debugging Kubernetes Part 1: An Introduction

Wed, 05 Jun 2024 06:12:40 +0000

Introduction to Kubernetes and Distributed Systems
Enter Kubernetes
- Why Kubernetes Stands Out
Kubernetes For Developers
- Kubernetes Basics In Practice
Final Word

While debugging in an IDE or using simple command line tools is relatively straightforward, the real challenge lies in production debugging. Modern production environments have enabled sophisticated self-healing deployments, yet they have also made troubleshooting more complex. Kubernetes (aka k8s) is probably the most well known orchestration production environment. To effectively teach debugging in Kubernetes, it’s essential to first introduce its fundamental principles.

Foojay Podcast #50: JCON Report, Part 2 - Maven, Software Security, Code Quality

Mon, 27 May 2024 08:07:54 +0000

This is part 2 of the interviews we recorded at the JCON conference earlier this month in Germany. In this episode, you get two main topics: Maven and Code Quality.

In the first part, you’ll hear Karl Heinz Marbaise and Steve Poole discuss the Maven project, the repository, Sonaytype, and the security impact of dependencies.

But next to security, we developers are also responsible for creating readable and maintainable code. Miro Wengner, Marit van Dijk, and Hinse ter Schuur dive into this topic, in the second part!

Diagnosing user-reported issues using WireQuery

Mon, 13 May 2024 07:11:04 +0000

As a developer, I’ve often struggled with diagnosing user-reported issues, which is often caused by a lack of information to reproduce the problem. While a ticket may contain a screenshot of the problem and a description, it often does not portray the complete picture. For example: what did the user do that led up to the issue? What endpoints were called from the frontend, and how did they respond? What did the underlying systems communicate? Etc.

Debug Without Breakpoints – Guide to IntelliJ IDEA's Pause

Mon, 22 Apr 2024 06:59:28 +0000

Read in other languages: 中文 Español Português

In a typical debugging scenario, you would set breakpoints to tell the debugger when to suspend your program. A breakpoint usually corresponds to the moment that marks the starting point of the further investigation.

However, in some situations you aren’t certain about where to set a breakpoint. Other times, you might prefer to suspend the program at a particular time rather than aiming at a specific line.

Tips for reading code

Tue, 26 Mar 2024 11:46:58 +0000

As developers, we read code more than we write it. When adding new features or fixing bugs, we first need to understand existing code, so we can make the right changes in the right place.

When reading code inside the IDE, IntelliJ IDEA helps us to read and understand code by providing helpful features like syntax highlighting and inlay hints. But there are more features to help us understand a piece of code.

Java top most detected issues

Wed, 14 Feb 2024 09:49:16 +0000

Using the telemetry from SonarLint after analyzing thousands of projects, these are the top most raised issues in Java projects.

We know that having clean code in our projects is important, and every developer would agree on that. But, according to what SonarLint telemetry shows, there are still lots of issues that appear in the huge list of analyzed projects.

From the SonarLint telemetry for the last 2 years, with more than 2.5 million issues, I have taken the top most common issues happening in Java projects, from the +600 rules covering the language, considering quality and security to see how we can avoid them and align our code a bit more towards having a consistent, intentional, adaptable, and responsible code.

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.

Java Flight Recording and Analysis with Azul Mission Control

Thu, 25 Jan 2024 07:59:42 +0000

Java Flight Recording (JFR) is a Java Virtual Machine (JVM) profiling and diagnostics tool. It enables you to collect and analyze data regarding the performance and behavior of a Java application. As JFR is included in the JVM, there is no need for additional tools or installations to make recordings of your applications.

By utilizing JFR, you gain valuable insights into the runtime behavior of your Java applications. It helps you to optimize performance, identify and troubleshoot issues, and ensure better overall reliability. JFR is designed with very low overhead, allowing its use in production environments with minimal impact on the performance of your application.

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:

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 )

Not a Single Trace

Fri, 20 Oct 2023 07:06:31 +0000

The Limiting Factor
Strength in Numbers
Example
Magical APIs
Final Word

Your team celebrates a success story where a trace identified a pesky latency issue in your application’s authentication service. A fix was swiftly implemented, and we all celebrated a quick win in the next team meeting. But the celebrations are short-lived. Just days later, user complaints surged about a related payment gateway timeout. It turns out that the fix we made did improve performance at one point but created a situation in which key information was never cached. Other parts in the software react badly to the fix and we need to revert the whole thing.

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.

Debugging Tips and Tricks: A Comprehensive Guide

Mon, 09 Oct 2023 07:12:23 +0000

Rubber Ducking: The Art of Talking it Out
Moving the Goalposts: Redefining the Bug
- The Evolution of a Bug
- The Process of Redefinition
Flipping the Direction: Multiple Angles of Attack
- The Linear Approach to Debugging
Disruptive Environments: Exposing Hidden Bugs
Leveraging Debugging Extensions and Tools
Disconnect and Reconnect: The Power of a Fresh Mindset
Embrace the Challenge: Finding Joy in Debugging
- Strategies to Embrace the Debugging Challenge
Use a Process
Conclusion

Debugging is an integral part of software development.

The Systemic Process of Debugging

Thu, 28 Sep 2023 07:06:14 +0000

The Importance of Issue Tracking
- Avoiding Parallel Work on the Same Bug
- The Value of Issue Over Pull Requests
Communication: Issue Tracker vs. Ephemeral Channels
- Why We Sometimes Avoid the Issue Tracker
- The Role of Daily Meetings
The Role of Testing in Debugging
- Starting with Unit Tests
- Unit Tests vs. Integration Tests
Final Word

Debugging is an integral part of software development. However, as projects grow in size and complexity, the process of debugging requires more structure and collaboration. This process is probably something you already do as this process is deeply ingrained into most teams.

The Evolution of Bugs

Tue, 12 Sep 2023 03:34:48 +0000

Memory Management: The Past and The Present
Concurrency: A Double-Edged Sword
The Pervasiveness of State Bugs
Exceptions: The Noisy Neighbor
Faults: Beyond the Surface
Thread Bugs: Unraveling the Knot
Race Conditions: Always a Step Ahead
Performance Pitfalls: Monitor Contention and Resource Starvation
Final Word

Programming, regardless of the era, has been riddled with bugs that vary in nature but often remain consistent in their basic problems. Whether we’re talking about mobile, desktop, server, or different operating systems and languages, bugs have always been a constant challenge. Here’s a dive into the nature of these bugs and how we can tackle them effectively.

Understand Stack Traces and how you can Debug Better With them

Tue, 05 Oct 2021 10:57:28 +0000

Recently a junior developer sent me an obfuscated stack trace and was pretty surprised when I instantly knew the problem and pointed him at the necessary change. To be fair, I had the advantage of being the person who put that bug there in the first place… But still the ability to glean information from a stack trace, even an obfuscated one, is a serious skill.

The stack trace in question was a ClassNotFoundException, that’s typically pretty easy and already tells you everything you need to know. The class isn’t there. Why it isn’t there is really a matter of what we did wrong. In this case, since the project was obfuscated, the bug was that this class wasn’t excluded from obfuscation.