CS 1713/1711 Introduction to Computer Science Laboratory 9

CS 1711 Recitation Laboratory 9:
Debugging and Profiling [11/9/99; 11/11/99]

Objectives:

Learn to use the debugger to single step through a program during its execution.
Learn to use the debugger to examine program variables.
Learn about breakpoints
Trace execution of a program.
Learn about program profiling.

Debugging Overview

Debugging is the process of finding and eliminating program errors. Program errors generally fall into four categories: syntax, linkage, runtime and algorithmic. Section 3.8, 6.8, 6.9, and 7.10 of the textbook discuss some aspects of program debugging. This section briefly describes the four types of errors and how you interact with Java WorkShop to debug them.

Syntax errors:
- The program doesn't follow the grammatical rules of the language.
- You know you have one because the program won't compile.
- Java Workshop highlights in yellow the first syntax error with a message about what it thinks the source of the problem is.
- Usually you can tell what the problem is if you carefully read the error message.
- If a class name is not recognized, you probably spelled it incorrectly or did not import the correct package.
Linkage errors:
- Occur because you haven't correctly connected the classes together.
- The symptom of a linkage error is an exception when the program starts to run.
- The most likely cause is that some of the needed directories aren't in your CLASSPATH. You can fix this error by specifying the name of the directory on the Class Path tab of the Properties option on the Project menu.
- You may also get an error if you haven't correctly added class files to your project.
- Another source of linkage errors occurs when you get a message to the effect that the main thread can't be found. You can fix this error by specifying the name of the class corresponding to the main program on the Run tab of the Properties option on the Project menu.
Runtime errors:
- Occur because the program performs an invalid operation (e.g. divide by zero) or exceeds system capability (e.g. run out of memory).
- For some errors such as divide by zero, the program will throw an exception. If your program catches and handles the exception, it can recover and continue executing. (We will be working on exceptions in Laboratory 11.) If the program doesn't handle the exception, the usual behavior is that it terminates and you get a long string of error messages on the Console Window.
- Some exceptions have to be explicitly thrown in order for action to take place. In these cases (e.g. an out of memory error), the program may just hang instead of terminating.
Logic errors:
- Occur because the fundamental design of the program is incorrect.
- Program may run to completion and exhibit no obvious problems.
- These are the most difficult errors to find.
- Use the debugger to trace your program to make sure that it is behaving the way you think it should.
- Use the profiler to get statistical information about how many times objects are accessed and what percentage of the time the execution of their methods takes.

Debugger in Java Workshop

Java WorkShop has an interactive debugger that is useful for finding runtime errors and for understanding how programs work. You can access the JWS debugger through the Debug menu bar or through the Debug Toolbar. The main way that we will be using the debugger is to set a stopping point in the program (a breakpoint) and then examining different program variables. More sophisticated ways of using the debugger are described in the JWS documentation that can be accessed through the Task-based Help option on the Help menu bar.

The Debug Toolbar is where:

Start/Restart executes the program under the debugger.
Toggle a breakpoint at the current cursor position in the Source Editor. (Set if clear; clear if set.)
Evaluate a program variable or expression at the point where the program was stopped.
Resume execution and run to the end. Use this to terminate debugging.
Run To Here executes to the point in the program corresponding to where your cursor is in the Source Editor window.
Step Over executes the statement at the cursor position in the Source Editor window. If the statement is a method call, execute the call completely.
Step Into executes the statement at the cursor position in the Source Editor window. If the statement is a method call, execute the first statement in the method .
Step Out executes the rest of the current method method call and stops at the return to the calling method.
Called shows the currently executing method.
Calling shows the method that called the currently executing method.

You have to build your project with the debug option to use these features of Java WorkShop. This is the default.

Laboratory details:

Check-off procedure:

You must attend the recitation and sign in. This laboratory will be checked off using the new procedures.

Warm up

Create a new standalone project called CrapsTestMain that contains the following code:

public class CrapsDebugMain {

    /**
     * Constructor.
     */
    public CrapsDebugMain () {
    }

    public static void main(String args[]) {
        Craps game = new Craps();
        game.playGame();
    }
}

Add the Dice and Craps classes to the project. They should be available on the disk in the teaching lab.

Dice.java

public class Dice {
    private int mySides;
    private int myLastRoll;

    //constructor
    public Dice (int sides) {
        mySides = sides;
        myLastRoll = 1;
    }

    //accessors
    public int getSides() {
        return mySides;
    }

    public int getLastRoll() {
        return myLastRoll;
    }

    //modifier
    public int roll() {
        myLastRoll = (int)(Math.random() * mySides) + 1;
        return myLastRoll;
    }
}

Craps.java

public class Craps {
    private Dice myDice;

    //constructor
    public Craps() {
        myDice = new Dice(6);
    }

    //modifier
    public boolean playGame() {
        int first = sumTwo();
        if (first == 7 || first == 11)
            return true;
        else if (first == 2 || first == 3 || first == 12)
            return false;
        else {
            int second;
            do {
                second = sumTwo();
            } while (second != first && second != 7);
            if (second == first)
               return true;
            else
               return false;
        }
    }    

    //helper
    private int sumTwo() {
        return myDice.roll() + myDice.roll();
    }
}

Make sure that you are compiling in debug mode. This should be the default, but you should check by looking at the Properties section under the Project menu. Select the Build tab and make sure that the Enable generation of debugging tables option is checked.
Build and run the project.

Part I: Executing to a certain point in your program.

Select the project CrapsDebugMain.
Open the Craps class in the Source Editor window.
Click on the following line in the playGame method:
```
     int first = sumTwo();
```
Push the Run to Here button: . The line above should be highlighted in green. You have run the program to this point in your program.
Push the Step Into button: . You should be at the first line of sumTwo:
```
     return myDice.roll() + myDice.roll();
```
We don't want to single step through the roll method calls, so we push the Step Over button: . This returns us back to the line:
```
     int first = sumTwo(); 
```
Push the Step Into button: to move to the next line.
Push the Evaluate button: . This pops up a menu. Type the word first in the Expression field. Push the Evaluate button. You will see the value of first on the Console Window at the bottom of the screen. (Had you entered something in the Value field of the popup window, you would have the option of assigning that value to first.)
Push the Resume button: to finish executing the program.

Part II: Setting a breakpoint

A breakpoint is a point in the program where you want the program to stop executing (take a break) so that you can examine its status. The debugging facility in Java Workshop allows you to set a breakpoint at virtually any point in the program. You can then examine your program variables and evaluate expressions based on these variables to determine the state of your program. This part of the laboratory takes you through the steps in setting a break point and examining the value of a variable.

Select the project CrapsDebugMain.

Add the following code to CrapsDebugMain:

     for (int k = 0; k < 5; k++)
         game.playGame();

Bring the Craps class into the Source Editor window.
Click at the beginning of the following line in playGame:
```
 
    if (first == 7 || first == 11)
```
Set a breakpoint at this line, but pushing the Toggle Breakpoint button .
Run to the first breakpoint by pushing the Start/Resume button .
Examine the value of first as described in Part I.
Push the Start/Resume button again to find the value on the next call to playGame.
Change the value of first to 8 to force the execution of the do-while loop in playGame. Use the Step Into button to single step through that iteration of playGame.

You can also set a count so that the program will stop after a specified number times that the statement at the breakpoint is reached (a counted breakpoint). You can read about these and other debugging features in the Java WorkShop documentation.

Part III: Profiling

Select the project CrapsDebugMain.

Modify the loop that you added to CrapsDebugMain in Part II:

     for (int k = 0; k < 50; k++)
         game.playGame();

Use the Profile button to have Java WorkShop analyze your program.
Try to understand the meaning of the different items in the Profiler window. Move the cursor over items in the Profiler window to get more information about the objects.
Save your file using the Print Ascii option on the File menu of the Profiler window.

Last revision: November 8, 1999 at 8:40 am.