Data Structures

Using the Java Debugger

As with the rest of the course, we will be working within VSCode for this Lab. Make sure you’ve installed all required extensions and removed any unnecessary ones, as stated on our Course FAQ page.

So far, you have most likely been running your programs using either the commands line (with compile commands), or using the VSCode run button. Now, you can use the drop down menu on the Run Button and select “Debug Java” to run the program in Debug mode instead.

Alternatively, you can click “Start Debugging” under the “Run” menu on the top toolbar.

If you simply do this instead of the normal Run Java / Run Without Debugging, it will appear to be exactly the same result. Your program will run and exit, and produce any expected output.

HOWEVER, running in debug mode allows us to make use of breakpoints, which pause the code at certain spots.

Breakpoints

Breakpoints allow you to define certain lines for the program to pause running at, while running in debug mode. This is extremely useful, as it allows you to investigate specific edge cases, or specific parts of the bugged code.

You can place a breakpoint by clicking to the left of the line number you want pause at. Breakpoints are represented by a red circle.

Then when you run in debug mode, the debugger will stop the program before executing that line, and will highlight that line to show it.

Nothing gets printed to the terminal yet, since that line of code has NOT been run yet.

You can also set Conditional Breakpoints, which will only pause if their given boolean condition is met. In this lab, you will use conditional breakpoints to pause the program at certain time values, to investigate the island at those times.

Once the breakpoint has been placed, edit it by left clicking on the breakpoint (red circle) and select Edit.

Then place a boolean condition in the text box that appears. These boolean conditions can be any valid condition, using any variables which are accessible from that line. i.e. “time == 110”, or even chained conditions like “time == 100 && cat.getName().equals(“Cat2″)”

For example, we can set a breakpoint in the following code snippet, then set the breakpoint to only pause when i==4.

Then if we run in debug mode, we will see that it pauses at that line when i == 4. And we can see in the terminal that everything before i == 4 has already been printed.

Note: If you set a breakpoint but the program does not stop when run in debug mode, it means that line was never executed. This is usually because the line was never reached, or because the program is infinitely looping somewhere earlier on (thus never progressing).

Debugger Toolbar

After the program pauses at a breakpoint, we want to be able to control it from there, and execute any number of lines, or continue running until the end. To do this, we can use the Debugger Toolbar.

The debugger toolbar appears when running a program (even in non-debug mode). For any program that is actively running (for example, when you have the Driver open), the toolbar will appear as follows:

When paused at a breakpoint, the debugger toolbar will look like this instead:

You can then use this toolbar to navigate forward through the code, either line by line, or section by section. The buttons work as followed:

  Continue button – Will resume running the code, until it hits another (or the same) breakpoint, OR the program ends.

Step Over – Will execute the highlighted line of code, and pause on the next line of code

Step Into – IF the highlighted line of code is a method call, you can use this to “step into” the method, and pause inside of it. This allows you to follow the logic when methods are being called.

Step Out – IF you have Stepped Into a method call, you can use this step back out. Aka to finish the method instantly, and stop on the next line after the method call.

The green circular arrow is the Restart button, which allows you to stop and rerun the program. The red square is the Stop button, which will stop running the program.

It is important to become familiar with the Debugger toolbar, in particular the “Continue” and “Step Over” buttons. They allow you to easily navigate code after breakpoints, and jump to other breakpoints to ease the search while debugging.

Memory Viewer

Also while the program is paused, you can use the Memory Viewer to inspect variable values. The memory viewer can be accessed through the left sidebar, under the “Run and Debug Menu”

You can then see all the current variables in scope at the paused line.

This allows you to inspect values, to ensure they get initialized/update as expected. This is important for bug-hunting thinks like NullPointerExceptions, as it lets you identify when things do/don’t get set to a value or null.

In the above example, the only two variables in scope are “args” (from the parameters of the main() method), and “i” which is the for loop variable from the conditional breakpoint example above.

If we define another String variable, and pause the program after that variable has been created, we can see it too.

Note: since the for loop has ended, the “i” variable has dissapeared and been garbage-collected by Java.

The String variable has a drop down menu in the variable viewer, since it is an object which has attributes. We can open this to see the attributes.

This is an important concept, as it allows us to investigate objects fully. Since the majority of Java code consists of objects, we need this to properly debug.

Debug Console

The final tool you will need to debug (and complete this Lab) is the Debug Console. The Debug Console is a special terminal, which can be accessed with Ctrl + Shift + Y (for Mac, use Command instead of Ctrl).

The debug console allows you to write and run singular lines of code, and print their output. For example, you can simply enter primitive values, and it will print those values back to you.

In the above screenshot, first “Hello!” is typed into the Debug Console (including the quote marks), then after pressing Enter, it is printed back to us. Second, the number 2 is entered, which again simply prints 2 back to us.

If we have a visible method which is accessible from the paused spot, we can call that as well and the Debug Console will print the output. If we use the previous example of the “String temp = “TempVariable”;”, and pause at the same spot, we can call that String objects methods and see the output.

This allows us to call getter methods to get values. In the lab, you will use this in combination with conditional breakpoints in order to get info from certain cats and the island, using methods like cat.numYarnCollected(), or island.numLandTiles().