Unfortunately, at this point in the book you don't know enough about writing code to be able to understand and fix certain kinds of bugs. For example, a program crashes if it tries to access an array entry that is outside of the array, but you won't learn about arrays until Lesson 16.

So why does this lesson cover debugging when you don't even know all of what can cause bugs or the techniques that you need to fix certain kinds of bugs? It makes sense for two reasons.

First, the previous lesson was the first part of the book in which you were likely to encounter bugs. Whenever I teach beginning programming, students start seeing bugs as soon as they write code that performs calculations like those covered in Lesson 11. These kinds of bugs are easy to fix if you know just a little bit about debugging but can be extremely frustrating if you don't.

Second, it turns out that you don't need to know more advanced techniques to learn simple debugging. Once you learn how to track down simple bugs, you can use the same techniques to find more advanced bugs. (If you learn to swim in 3 feet of water, you can use the same techniques to swim in 10 feet or 100 feet of water.)

Later, when you know more about Visual Basic programming and deal with more advanced bugs, that same knowledge will help you fix those bugs. When you know enough to have array indexing errors, you'll also know enough to fix them.

Back in the bad old days, programmers often fixed bugs by staring hard at the code, making a few test changes, and then running the program again to see what happened. This trial-and-error approach was extremely slow because the programmer didn't really know exactly what was going on inside the code. If the programmer didn't have a good understanding of what was really happening, the test changes often didn't help and sometimes made the problem worse.

Visual Studio's IDE provides excellent tools for debugging code. In particular, it lets you stop a program while it is running and see what it's doing. It lets you follow the program as it executes its code one line at a time, look at variable values, and even change those values while the program is still running.

The following sections describe some of Visual Studio's most useful debugging tools.

A breakpoint stops code execution at a particular piece of code. To set a breakpoint, open the Code Editor and click the gray margin to the left of the code where you want to stop. Alternatively, you can place the cursor on the line and press F9. The IDE displays a red circle to show that the line has a breakpoint.

Figure 12-1 shows a breakpoint set on the following line of code:

Dim grandTotal As Decimal = subTotal + salesTax + shipping

Figure 12.1. Figure 12-1

If you run the program now, execution stops when it reaches that line. You can then study the code as described in the following sections.

The debugger provides an edit-and-continue feature that lets you modify a stopped program's code. You can add new statements, remove existing statements, declare new variables, and so forth. Unfortunately, some changes confuse the debugger, and you'll have to restart your program. But sometimes you can make small changes without restarting.

To remove a breakpoint, click the red breakpoint circle or press F9 again.

It's easy to read a variable's value while execution is stopped. Simply hover the mouse over a variable and its value appears in a popup window.

For example, consider the TaxCalculator program shown in Figure 12-2. The program is supposed to add a subtotal, 9% sales tax, and shipping costs to get a grand total. It doesn't take Stephen Hawking to realize that something's wrong. If you're really paying $204.50 for a $19.95 purchase, you need to find a new place to shop.

Figure 12.2. Figure 12-2

To debug this program, you could place a breakpoint on a line of code near where you know the bug occurs. For example, the line of code containing the breakpoint in Figure 12-1 calculates the grand total. Because the total displayed in Figure 12-2 is wrong, this seems like a good place to begin the bug hunt. (You can download the TaxCalculator program from the book's web site and follow along if you like.)

When the code is stopped, you can hover the mouse over a variable to learn its value. If you hover the mouse over the variables in that line of code, you'll find that subTotal is 19.95 (correct), shipping is 5 (correct), and salesTax is 179.55 (very much incorrect). Figure 12-3 shows the mouse hovering over the salesTax variable to display its value.

Figure 12.3. Figure 12-3

Now that you know the bug is lurking in the variable salesTax, you can hover the mouse over other variables to see how that value was calculated. If you hover the mouse over the variables in the previous line of code, you'll find that subTotal is 19.95 (still correct), and taxRate is 9.

You may need to think about that for a bit to realize what's going wrong. To apply a tax rate such as 9%, you divide by 100 and then multiply. In this case, taxRate should be 0.09, not 9.

Having figured out the problem, you can stop the program by opening the Debug menu and selecting the Stop Debugging command or by clicking the Stop Debugging button on the toolbar (see Figure 12-4).

Now you can fix the code and run the program again to see if it works. The following line shows the incorrect line of code (I scrolled it out of view in Figure 12-3 so it wouldn't be a complete giveaway):

Const taxRate As Decimal = 9D

If you change this to 0.09D and run the program again, you should get the correct a sales tax $1.80 and the grand total $26.75. In a more complicated program, you would need to perform a lot more tests to ensure that the program behaved properly for different inputs, including weird ones such as when the user enters "ten dollars" for the subtotal or leaves the shipping cost blank. This example isn't robust enough to handle those problems.

Once you've stopped the code at a breakpoint, you can step through the execution one statement at a time to see what happens. The Debug menu provides four commands that control execution:

In addition to using the Debug menu or shortcut keys, you can invoke these commands from the toolbar. Figure 12-4 shows the debugging-related buttons in the Standard toolbar.

Figure 12.4. Figure 12-4

Normally the program steps through its statements in order, but there is a way to jump to a particular line of code if you feel the need. Right-click the line that you want the code to execute next and select Set Next Statement from the context menu. Alternatively you can place the cursor on the line and press [Ctrl]+F9. When you let the program continue, it starts executing from this line.

Setting the next statement to execute is useful for replaying history to see where an error occurred, re-executing a line after you change a variable's value (described in the "Using the Immediate Window" section later in this lesson), or jumping forward to skip some code.

Note that you can jump only to certain lines of code. For example, you can't jump to a comment or other line of code that doesn't actually do anything (you can't set a breakpoint there either), you can't jump to a different method, you can't jump at all if an error has just occurred, you can't jump to a variable declaration unless it also initializes the variable, and so forth. Visual Basic does its best, but it has its limits.

Sometimes you may want to check a variable's value frequently as you step through the code one line at a time. In that case, pausing between steps to hover over a variable could slow you down, particularly if you have a lot of code to work through.

To make monitoring a variable easier, the debugger provides watches. A watch displays a variable's value whenever the program stops.

To create a watch, break execution, right-click a variable, and select Add Watch from the context menu. Figure 12-5 shows watches set on the variables salesTax and subTotal. Each time the program executes a line of code and stops, the watches update to display the variables' current values.

Figure 12.5. Figure 12-5

The Watch window also highlights, in red, any variables that have just changed. If you're tracking a lot of watches, this makes it easy to find the values that have changed.

While the program is stopped, the Immediate window lets you execute simple commands. The four most useful commands that this window supports let you view variable values, evaluate expressions, set variable values, and call subroutines.

To view a variable's value, type a question mark followed by the variable's name and press [Enter].

The following code shows the contents of the Immediate window after I asked for the value of the salesTax variable:

?salesTax
179.55D

To evaluate an expression, type a question mark followed by the expression and press [Enter]. You can include literal values, variables, properties, constants, and just about anything else that you can normally include inside an expression in the code.

The following text shows the Immediate window after I typed an expression and pressed [Enter]:

?taxRate * subTotal
179.55D

To set a variable's value, simply type the variable's name, an equals sign, and the value that you want to give it. The new value can be a literal value or it can be the result of an expression. After you press [Enter], the Immediate window evaluates whatever is on the right of the equals sign and saves it in the variable.

Finally, to call a subroutine, simply type the subroutine call into the Immediate window and press [Enter]. Don't forget to add parentheses and parameters if they are required. If the method has a return value, start with a question mark to make the Immediate window display the result.

If you look closely at Figure 12-6, you'll see that this program has a serious problem. One tofu dinner at $13.95 each doesn't add up to $142.65. If you look a little more closely, you'll also see that the grand total doesn't add up properly.

Figure 12.6. Figure 12-6

In this Try It, you debug this program. You set breakpoints and use the debugger to figure out where the code is going wrong.

' Calculate the prices for each entree and the total price.
Private Sub btnCalculate_Click() Handles btnCalculate.Click
    Const costChicken As Decimal = 15.95D
    Const costSteak As Decimal = 18.95D
    Const costTofu As Decimal = 13.95D

    ' Get inputs.
    Dim numChicken As Integer = Integer.Parse(txtNumChicken.Text)
    Dim numSteak As Integer = Integer.Parse(txtNumSteak.Text)
    Dim numTofu As Integer = Integer.Parse(txtNumTofu.Text)

    ' Calculate results.
    Dim total As Decimal = 0

    Dim priceChicken As Decimal = costChicken * numChicken
    total += priceChicken

    Dim priceSteak As Decimal = costSteak * numSteak
    total += priceSteak

    Dim priceTofu As Decimal = costTofu * numTofu
    total += priceTofu

    ' Display results.
    txtPriceChicken.Text = priceChicken.ToString("C")
    txtPriceSteak.Text = priceSteak.ToString("C")
    txtPriceTofu.Text = priceTofu.ToString("C")
    txtTotal.Text = total.ToString("C")
End Sub

txtPriceTofu.Text = priceChicken.ToString("C")