Debuggers

Anyone learning pro­gram­ming will un­doubt­ed­ly come across the term “debugging” sooner or later. This process refers to a complete check of the source code of a computer program, which aims to uncover any errors contained in the code. If you want your developed software to work as intended on all target platforms and devices, using a debugger will be ab­solute­ly essential. In the following article, you’ll learn what a debugger is, how these useful programs work, and where they are typically used.

A debugger is a computer program that allows you to uncover and diagnose errors in computer software. The aim of debugging tools is to ensure the long-term func­tion­al­i­ty of the given software on all intended devices and platforms. For this reason, many debuggers not only examine the re­spec­tive source code but also the in­ter­ac­tion with the executing operating system and un­der­ly­ing hardware. The debugging process takes place during runtime, meaning the software does not need to be closed down for the check.

Debugging contains “bug” because this word has been used for decades to describe all sorts of pro­gram­ming errors in software de­vel­op­ment. Engineers even called mal­func­tions “bugs” as early as the 19th century. Based on this term, a solution to a software error is said to be a “bugfix”.

There is no such thing as perfect software without bugs. Daily op­ti­miza­tion is therefore in­dis­pens­able. Here, the big problem often lies not in finding faulty processes in the pro­gram­ming sequence, but in de­ter­min­ing their exact cause. Even just a mis­po­si­tioned bracket or an in­cor­rect­ly used operator can result in a program no longer func­tion­ing properly. In the case of hundreds or even thousands of lines of code, manual searches performed row by row offer little prospect of success. For this reason, modern debugging tools not only provide in­for­ma­tion that a problem has been de­ter­mined, but also offer extensive details on the type of error and which code lines contain the error.

Normally, debuggers work through the program code in a step-by-step manner. Break­points are, therefore, defined in the software to be debugged. The debugging tool rec­og­nizes these break­points and can use them to stop running the software at exactly these points. For de­vel­op­ers, this opens up the following two pos­si­bil­i­ties:

• It is possible to examine the exact state of the program at this time. For instance, it is easy to check whether all in­te­grat­ed variables have output the expected values.
   
• It is possible to play the program from the re­spec­tive break­point to delineate any problems or sources of errors.

The break­points do not need to be fixed. Many debuggers allow break­points to be tied to in­di­vid­ual con­di­tions. This way, the program can stop under certain cir­cum­stances. For example, if a loop undergoes 20 passes correctly and only en­coun­ters a program error on the 21st pass, the debugger can launch directly into the problem case thanks to a cor­re­spond­ing condition. In other words, the previous incident-free passes do not need to be repeated.

The other functions of debuggers include the in­spec­tion of data, such as the content of variables, repos­i­to­ries or registers, as well as the mod­i­fi­ca­tion of memory, such as the main storage (working memory) or the processor register.

How exactly a debugger can be used for trou­bleshoot­ing in software depends on the tool itself as well as the operating system the software (and bugger) are running on. As the user, you tell the trou­bleshoot­ing tool which process it should connect with – either with a process ID or a name. In the case of the latter, the debugger initially finds out the as­so­ci­at­ed process ID. Next, a system request initiates the debugging session.

In general, there are two ap­proach­es for the use of debugging tools:

• The trou­bleshoot­ing process is performed within the system a software runs on.
   
• The trou­bleshoot­ing process is not launched on the computer the software runs on. Instead, it is initiated by a remote system – this is called remote debugging.

Modern debuggers are often able to take into account changes to the source code of a software during execution. Known as just-in-time debugging, this is es­pe­cial­ly popular during the early de­vel­op­ment phase of a computer software, where minor and major code errors are by no means uncommon. It is not without reason that the de­vel­op­ment en­vi­ron­ments of a wide range of script languages and frame­works also feature an in­te­grat­ed debugger.

When it comes to debuggers or debugging in general, if computer code is to work as flaw­less­ly as possible for the long-term, running a trou­bleshoot­ing process becomes in­dis­pens­able – no matter whether you want to program, further develop or test a simple script, a single process, a module, a complex program or a complete operating system.

In the case of non-pro­gram­mers, it is ben­e­fi­cial if a software features a suitable debugger. When designed and con­fig­ured ap­pro­pri­ate­ly, the tool can act like a mouth­piece between program users and de­vel­op­ers in the event of errors during use. Thanks to debugging reports, the de­vel­op­ers can more easily reproduce the error and determine how the user can solve the problem with the software. Depending on the program, debugger, and severity of the error, an in­te­grat­ed debugging tool can even allow users of a software program to carry out trou­bleshoot­ing on their own.