A Debugging Strategy

To Documents

A Debugging Strategy

Definition of Bug

A bug is a fragment of code that does not behave according to its specification.
Debugging is the process of finding, understanding and fixing bugs.

The Steps to Debugging

Find the code fragment that is causing the problem (hard).
Understand why the buggy code is causing the problem (moderately easy once you have found the bug).
Fix the bug (easy once you understand the bug).
If you understand the bug, you should be able to reproduce it, that is, know what input causes the bug and what input does not cause the bug.
Test the fixed code to make sure that fixing the bug did not cause new bugs.

Finding the Bug Location

If you do not have an idea of where to look for a bug, use binary search:
1. Place println statements at the beginning (A), the middle (B), and the end of the main method (C). The println statements should print the values of important variables or objects. (The toString method of the object is valuable for debugging). The print statements might look something like this:
```
public static void main(String[ ] args)
{
    System.out.printf("Point A: a==%d b==%s c==%f\r\n", 
                                               a, b, c);

    // Statements from top half of main.

    System.out.printf("Point B: a==%d b==%s c==%f\r\n", 
                                               a, b, c);

    // Statements from bottom half of main.

    System.out.printf("Point C: a==%d b==%s c==%f\r\n", 
                                               a, b, c);
}
```
2. Run the code. If the println statements indicate no error at A but an error at B, the bug is in the top half.
3. If the println statements indicate no error at B but an error at at B, the bug is in the bottom half.
4. Add another statement in the middle of the half that contains the bug; keep searching for the bug with this binary search procedure.
5. If you arrive at this situation:
```
    System.out.printf("Point M: a==%d b==%s c==%f\r\n", 
                                               a, b, c);
    x.f( );      // Method call.

    System.out.printf("Point N: a==%d b==%s c==%f\r\n", 
                                               a, b, c);
```
  and the output indicates that there is not an error at M, but there is an error at N, the bug is quite probably in the method f. Repeat the same binary search procedure within the method f that you used for the main method.
If you do have an idea of where to look for the bug, use binary search within that region.

Understanding the Bug

After you have located the bug, do not try to fix the bug until you understand it.
Understand which inputs cause the bug, and which inputs do not cause it.

Other Things to Consider

Be careful of the double version problem: the binary code that you are running comes from a different source code file than the one that you are editing.
Be suspicious of these statements:

Rather than removing print statements when you think you have found the bug, leave them in like this:

public static void main(String[ ] args)
{
    boolean debug = true;

    // statements

    if (debug)
        System.out.println("Point N: " + a + " " + b);

    // more statements
}

When you are finished debugging, change debug = true to debug = false.