Many people might think this a simple question; I am not one of them. I feel that in the modern world of development, there are too many factors to pick a single tool for debugging any language, let alone Java.

In The Beginning

Let's take a step back and look at where we started with debugging, and while I am not going to get into the history of debugging, we should look at some of the basic tools used for debugging Java, aside from logging and system-out.

JDP

Let's start with a quick look at the Java debugger (Java Discovery Protocol - JDP), which is a command-line tool used for debugging Java applications. This tool ships directly from Oracle, so you can be sure it will work; however, it can be complex to use and require knowledge of where you want to debug ahead of time.

A positive aspect of this tool is the fact that you can use it on the same box where the Java Virtual Machine (JVM) is running. This set-up means you do not need to deal with the complexities of connecting any external service that might be restricted by firewalls, which is particularly useful if you are deploying your Java applications into Docker containers. (which let's be honest, who isn't).

And while a command-line tool is not the best option for everyday work, what other options are available?

IDEs

Integrated Development Environments (IDEs) provide a suitable method of easily debugging your applications while helping streamline the development process by removing a lot of the pain related to configuring a project and remembering the numerous APIs that are inherent with coding.

While there are many IDEs available, NetBeans, Eclipse, and (my favorite) Intellij, from JetBrains, are the best three for Java. While there are other options on the market, what makes these tools stand-out is their extensive support and expertise in this programming language.

With any of these IDEs, you can easily debug your application and view the data alongside the code that triggered it, and view data changes as the program progresses. What differentiates IDEs are that some apps have fairly basic toolsets, whereas others are more advanced, allowing for additional debugging features, such as inline variable views and expression evaluation.

The Next Level

While the tools, processes, and methods of program development have grown and changed – debugging has not evolved. In most modern applications, we are dealing with distributed systems, microservices, and a growing number of serverless deployments.

Old-school traditional debugging tools are struggling with these new environments due to complex and virtualized networks, restricted resource allocations, and multiple deployments. The changing level of complexity raises the question; how do you debug an application using an IDE when 20 instances are running across a distributed environment? You can't, it does not work.

The Future. Next-Gen Debugging.

To live and survive in a world of virtualized networks, complex, and multiple deployments, what you need is a tool designed to handle today's complexities. NerdVision, built from the ground-up for today's environment by the team who developed the award-winning FusionReactor, enables you to debug your modern applications with the ease and efficiency can you cannot get with IDEs built for yesterday's architecture.

NerdVision helps programmers reduce the time spent debugging by not having to redeploy your application to enable debugging or logging. Programmers install and change Tracepoints (a kind of breakpoint, that does not block your application) without restarts. Better yet, the same toolset works on data that has already been deployed in production or is still local.

NerdVision delivers a full set of features that you see in IDEs:

• Secure access to your git repository
• Full support for conditional breakpoints
• Full support for custom watch statements
• Broad or targetted debugging of 1 or many instances of your application simultaneously
• Collaboration with team members to debug together
• Cloud-based debugging
• Long-lived tracepoints across redeploys

The company's vision is to help programmers evolve their development and debugging efforts to support today's application reality. Developers who are embracing this new method of debugging, locally or in production, are more productive, have less downtime, and have positioned themselves for tomorrow's challenges.

Summary

To summarise, the best debugger for Java is dependent on your use case; if you are debugging in an isolated environment, then a tool like JDP is useful, even though it requires a high skill level. If debugging a single application locally, then a full IDE is hard to beat. However, when it comes to debugging distributed systems, a tool like NerdVision is critical and is likely something you should be using today – for both the distributed systems and your isolated and local applications.