Debug code

Debug code is computer code introduced to a computer program to test for errors or to help determine the cause of an error. It can be as simple as an echo command to print the value of a variable at certain points of a program. Modern integrated development environments sometimes render this unnecessary by allowing the placement of stop points at specific places in the program, and providing the ability to view the value of variables through the IDE rather than program output.

Uses of debug code[]

Debug code's main function is to help debug code. This can do this in several ways, such as using print statements, assert commands and unit testing.

Use in coding[]

Small statements can be added to code in order to find the presence and the location of bugs within a program. It can also be used to provide test inputs to simulate possible use cases that a program might need to be able to accept. It can also be used as a place holder for code that is still in development.

Use in video games[]

Many video gaming mod, cheat codes, such as , invincibility, etc. were originally introduced as debug code to allow the programmers and/or testers to skip hindrances that would prevent them from rapidly getting to parts of the game that needed to be tested; and in these cases cheat modes are often referred to as .

It is recommended as a best practice that debugging code be removed from production versions of applications, as it can slow them down.^[1] However some games leave these commands and cheats available for the players to use as a way to enhance their play experience. For example, the PC version of Skyrim allows the player access to the command console, giving them the ability to modify certain aspects of their game as it is being run. These commands include giving the player invincibility, teleportation and unlimited gold.^[2]

Examples of debug code[]

Print debugging[]

Print debugging is making use of print statements in order to find and isolate bugs in a program. It can be used to track the flow of data values of a piece of code. This type of debug code has some distinct disadvantages. It is temporary and usually removed when the bug is solved. The use of many print statements can affect the actual output of a program and slow down the run-time, depending on how often print statements are called. In some cases print statements do not help find the problem, for example the C++ stdout has a buffered output, and sometimes the contents of the buffer are lost leading to incorrect debugging information.^[3]

C++ example[]

void TestFunction(int timesToRun) {
  cout << "the algorithm should run " << timesToRun << " times" << std::endl;
  for (int i = 0; i <= timesToRun; i++) {
    // run algorithm
    algorithm();
    // debug print statement
    cout << "algorithm run " << i++ << " times." << std::endl;
  }
}

There is a bug in the above code. On an input of 5 the program should print the following to the console.

the algorithm should run 5 times
algorithm run 1 times.
algorithm run 2 times.
algorithm run 3 times.
algorithm run 4 times.
algorithm run 5 times.

The actual output is the following, which is incorrect.

the algorithm should run 5 times
algorithm run 1 times.
algorithm run 2 times.
algorithm run 3 times.
algorithm run 4 times.
algorithm run 5 times.
algorithm run 6 times.

Our function is running through the algorithm an extra time, and upon closer inspection it is clear that our loop is coded wrong.

Assert statements[]

Usually the best time to fix a bug is before the program is run. This can be done by inserting assertions into the code. In C this can be done using the assert() command. An assert command can check to see if the program is running the correct conditions at this point in the program.^[4]

C example[]

int i, a[10];
for (i = 0; i < 10; ++i)
{
  a[i] = 10-i;
}
for (i = 0; i < 10; ++i)
{
  a[a[i]] = a[i];
}

The above code will cause has an out of bounds error which can lead to some unexpected results. The code can be written in a safer way, using assertions, as shown below.

#include <assert.h>
int i, a[10];
for (i = 0; i < 10; ++i)
{
  assert(0 <= i && i < 10);
  a[i] = 10-i;
}
for (i = 0; i < 10; ++i)
{
  assert(0 <= i && i < 10);
  assert(0 <= a[i] && a[i] < 10);
  a[a[i]] = a[i];
}

JUnit[]

JUnit is a simple framework used to write repeatable test available for java, and allows programmers to create their own unit test. A unit test is code that is written to execute a specific function in the code to be tested and usually targets a small unit of code, such a single method or class. Using a combination of assert statements and other test statements, programmers can create suites of test cases in order to tell if a method or function is being executed properly.^[5]

References[]