### Step 4: Stepping

What we want to do is execute one line of code at a time, to see how each line of code affects the program's output and the state of its variables. This process is called stepping. There are two types of stepping: step over and step into. We will have to use both kinds of stepping to solve our problems, and each kind will be disused in turn.

Step over executes one line of code in its entirety. For example, if the line contains a statement such as a method call, the method is run entirely in the background and execution continues within the calling block of code. This is the kind of stepping that we want to do on line 22 of our program (we are not interested in the way that `System.out.println()` works). So, in the Gild Debug View, press the "Step Over" button. Line 22 will execute, and the program should stop on the next executable line (line 24). Notice that some output in the Console View at the bottom of your screen has changed. It now displays:

`The current power of 2 is 1`

This is the output that we expect: the first power of two that we should print (20) is 1.

The documentation of `getNextPower(int)` tells us this:

So, if `getNextPower(int)` is working correctly, given that the current value of `powerOfTwo` is 1, `getNextPower(int`) should assign 2 to`powerOfTwo`. Let's step over line 24 to see what is assigned to `powerOfTwo`. Press the "Step Over" button.

Two things of note will happen: first, the debugger will execute line 24, and stop on the next executable line (line 26); second, the information in the Gild Debug View will change. Let's look at that information:

Notice how the colour of `powerOfTwo`'s label has changed to red. This is to signal to us that the value of `powerOfTwo` has changed. If `getNextPower(int)` worked as we should expect, then `powerOfTwo`'s value should now be 4. But it is not 4, it is 3. Something is wrong with `getNextPower(int)`. We are going to want to inspect what `getNextPower(int)` is doing.

To see what `getNextPower(int)` is doing, use the "Step Over" button three times so that execution is stopped on line 24 (the one that contains the call to `getNextPower(int)`). This time, we do not want to step over the line. We want to see what is happening within`getNextPower(int)`. That is what step into is for.

Step into will execute one line of code, but it will stop execution within whatever calls that line makes (for example, a method call). We want execution to stop within `getNextPower(int)`. Click on the "Step Into" button of the Gild Debug View.

Two things will happen: first, execution will stop on line 40 of our program (the first line `of getNextPower(int)`); second, the data in the Gild Debug View will change. The data will change to this:

Notice that `args` and i are no longer included, and that `currentPower` is new to the data. This is because the former two were local variables to the `main(String[])` method of our program. We are no longer in the `main(String[])` method, so those two variables are no longer visible. `currentPower`, however, is local to `getNextPower(int)`, so it appears in the Gild Debug View.

Now, let's inspect the code of `getNextPower(int)`. It only has one line, and it is as follows:

The logic error is obvious: if we want to find powers of two, the arithmetic operation we need to use is multiplication; but we are here using addition. We are going to have to change this line of code. But first, we must terminate our program.

Previous | Next