General Debugging Techniques

Aim of debugging

Debugging aims to explain the product’s behavior through code, i.e., be able to point out what and why the code is executing the way it is, leading to the incorrect result from the product. We must trace the code path(s) and the internal state the process has followed and narrow down the code path that missed the scenario or input causing the bug. The codebase will play a significant role in this quest. The better one knows the code base, the faster one will crack the bug. But only some people know the entire codebase. The codebase might include various third-party software or open-source code their product uses. So, most of the time, debugging will involve understanding code, and this is what our tools will help us do.

Many language and platform-specific tools are available for debugging, which we’ll not discuss. In this section, we’ll concentrate on agnostic tools. The tool that we use will depend significantly on our understanding of the code. If we know the code we are dealing with, we might only need the code to crack the bug.

Here are a few key pointers:

• A complete novice to the product and the code might need much diagnostic information and reproduce the bug to root cause it.

• Someone with mid-level experience might be fine with the logs and other diagnostic information.

• The more experience one has, the less diagnostic information one may need to debug the issue. The bug report or a code walkthrough can tell an experienced programmer the root cause.

• A professional might not even need the codebase. They will look at the bug report and intuitively know what the issue is. This is not remarkable if the system is small or the debugger is the code’s author, but that is different from the one typically dealt with in modern enterprise software.

In short, the more experience a programmer has (either with the code or debugging in general), the fewer tools they would need and vice versa.

Debugger’s toolkit

As mentioned before, all our tools and techniques for debugging help the debugger understand the code’s behavior. Tracing the program’s flow of execution is a crucial technique, and various techniques and tools will come in handy for this. It will also help one understand the code base better. Reproducing part or the whole of the issue is another critical skill that will help.

Logging is an important tool that best communicates the system’s state to its users. Each tool will have its strengths and the effort needed to use them. The aim is to minimize the time and effort required. Like with most things, there is no clear-cut way to use these tools. A combination of the tools is needed based on the issue.