Debugging Algorithm Structure

Stepwise refinement turns a complex task into smaller steps until it can be translated into programming-language syntax.

Programming

A Program That Runs but Gives the Wrong Answer

Many beginners assume that once a program is accepted by the computer, the algorithm inside it must be correct. That assumption is false. A program can be accepted by the computer and still fail to carry out the intended algorithm. When the output is wrong, the problem is often not in a single line of code but in the structure of the algorithm: which steps exist, how many times they repeat, and whether the repeated steps sit in the right place. This article shows how to inspect that structure, step by step, so you can find the point where the program leaves the path that would produce the intended result.

What do you think happens?

Suppose a loop is supposed to add interest once per year for five years, but the line that increases the counter is written after the closing brace of the loop. What happens to the counter?

It increases once per year as intended
It never increases, so the loop's stopping check never changes
It increases five times and then stops automatically

Reveal answer

Answer:

It never increases, so the loop's stopping check never changes

The counter only changes when the statement that changes it runs. If that statement is outside the loop body, it is not part of the repeated process, so the check sees the same counter value on every pass. Because the check is still true, the loop keeps running. The source explains that the complete repeated process, including the counter update, must be inside the loop body.

Tracing an Investment Year by Year

Consider an investment program that starts with an initial value, applies an interest rate, and displays the value after each of the next five years. The task is easy to describe in words. The question is how to write it as an algorithm. The most direct way is to write the same group of instructions five separate times, once for year 1, once for year 2, and so on. This approach can describe the task correctly, but it repeats the same pattern and hides the general structure of the solution.

Each year's work is the same group of operations: compute the interest on the current value, add the interest to the value, and display the new value. Only the year changes. Because the operations are identical, the five separate blocks can be replaced by one repeated block. The diagram below compares the two versions. The left side lists every year as its own instruction group. The right side keeps one group and marks it as the body of a loop that runs for each year.

Which written steps repeat, and what changes between repetitions? The yearly operations are identical, and the year number is the only thing that differs from one pass to the next.

Refining a Task Into Precise Steps

Stepwise refinement is the method of turning a complex task into smaller steps until each step is precise enough to translate into programming-language syntax. You begin with a high-level statement of what the program must do. Then you break that statement into sub-steps. Then you break each sub-step further, and you keep going until every step names a concrete action the computer can carry out. The source summarizes the idea this way: stepwise refinement turns a complex task into smaller steps until it can be translated into programming-language syntax.

Definition

Stepwise refinement: the process of repeatedly breaking a complex task into smaller, more precise steps until the algorithm is detailed enough to be translated into the syntax of a programming language.

Inside a Counting Loop

A loop is a control structure that allows a block of code to execute repeatedly. A counting loop uses a counter to control how many times the block runs. The counter has three jobs, and each one is a separate place where the algorithm can go wrong. First, the counter is initialized to a starting value. Second, it is updated, which means increased by one for each iteration. Third, a condition is checked before each pass, and the loop stops when that condition is no longer true. The source describes this as starting a counter, incrementing it for each iteration, and stopping when the condition is no longer true.

On each pass through the loop, what value does the counter hold, when is it increased, and at what point does the check fail so the loop stops? The diagram follows the counter from initialization through two passes and the final check.

The diagram is a generated illustration of the counter's life cycle, not a literal trace of the source's code. Read it from the top. The counter starts at zero. Each pass checks the condition first, and if the condition is true, the counter is increased before the body runs. The body is the repeated process. After the fifth increase, the check no longer holds and the loop stops. If any of the three jobs fails, the loop's behavior changes: a missing initialization leaves the counter with an unintended starting value, a missing update means the check never changes, and a wrong condition stops the loop too early or too late.

Code walkthrough

double principal = 1000.0;
double rate = 0.05;
int year = 0;
while (year < 5) {
    year = year + 1;
    double interest = principal * rate;
    principal = principal + interest;
    System.out.println("Year " + year + ": " + principal);
}

1
Line 1 and 2 store the initial value and the rate. These are inputs to the algorithm.
2
Line 3 initializes the counter year to zero. This is the first of the three counter jobs.
3
Line 4 is the stopping check. The loop continues while year is less than 5.
4
Line 5 updates the counter. Because it is inside the braces, it runs on every pass.
5
Line 6 computes the interest from the current principal and the rate.
6
Line 7 adds the interest to the principal, which becomes the value for the next year.
7
Line 8 displays the value for the year just processed.
8
Line 9 closes the loop body. The next check happens before the body runs again.

The counter year is initialized to zero before the loop.
The while condition is checked before each pass.
The counter is increased inside the braces, so it changes on every pass.
The interest and principal updates are part of the repeated body.
The display statement runs once per pass, showing the value for that year.

Tracing Where the Result Diverges

When a program produces a result different from the intended algorithm, the goal is to locate the divergence. The source recommends comparing the refined steps with the translated structure and asking four questions: whether the counter is initialized, whether it changes, whether the stopping condition is correct, and whether every yearly operation remains inside the loop. Those four questions cover the main places where a counting loop can leave the intended path.

Following the algorithm's decision point step by step, at which step does the actual path first leave the path that produces the intended result? In this version, the increment has been moved outside the loop body, so the check never changes.

Read the flowchart as a set of decision points. The divergence happens at the first step where the actual path stops matching the intended path. Here, the intended path increases the year before each check, so the check eventually fails. In the faulty version, the increment is reached only after the display step and is not on the repeated path back to the check. The check therefore compares the same year value on every pass. The divergence is not at the check itself, which is written correctly. It is at the placement of the update, which is the first step that breaks the chain of changes the loop depends on.

Worked example

Locating a Divergence in an Investment Loop

A program is meant to display the investment value for years 1 through 5, but it displays the same year-one value over and over and never stops by itself. Locate the first step where the program leaves the intended result.

1
Check the initialization
The counter starts at zero, which matches the intended design. The initialization is not the divergence.
2
Check the update
The counter is never increased on the repeated path. The update is placed outside the loop body, so it is not part of the repeated process.
3
Check the stopping condition
The condition year less than 5 is written correctly. It would stop the loop if the counter ever changed, but the counter does not change, so the condition is never reached.
4
Check the loop body
The interest and display steps are inside the body. They run each pass, which explains the repeated output.
5
Identify the divergence
The first step where the path leaves the intended result is the misplaced increment. Moving it back inside the braces restores the chain of changes the loop depends on.

Result

The divergence is the placement of the counter update outside the loop body. Moving the update inside the body, before the display step, makes the counter change on every pass and lets the stopping condition take effect.

Syntax Errors Versus Semantic Errors

Two kinds of mistake can appear in a loop, and they behave very differently. A syntax error breaks the rules of the programming language, so the program cannot be translated or run as written. A semantic error follows the language's rules, so the program runs, but the algorithm it carries out is not the intended one. The source's central lesson applies here: a program can be accepted by the computer and still fail to carry out the intended algorithm. A semantic error is exactly that case.

Feature	Syntax error	Semantic error
What is wrong	The code breaks the language's grammar	The code is valid but does the wrong thing
Does the program run	No, it is rejected before the loop runs	Yes, it runs and produces output
Typical loop example	A missing brace or a misspelled keyword in the while statement	The counter update placed outside the loop body
Where to look	At the exact line the language reports	At the structure: initialization, update, condition, and body membership
How to find it	Read the language's error message	Trace the counter and the output against the refined steps

Syntax errors stop the program from being accepted; semantic errors let it run while the algorithm drifts from its intent.

This distinction shapes how you debug. A syntax error announces itself, so the fix is usually local and mechanical. A semantic error gives no such warning, so you need to reason about the algorithm's structure. For a loop, that means asking what the counter holds on each pass and whether each yearly operation is part of the repetition. The four questions from earlier are the tools for this reasoning.

Mistakes Beginners Make With Loop Structure

Common mistake
Writing the same steps once for every case instead of using a loop
What it looks like
Writing separate instruction groups for year 1 through year 5 when each group is identical except for the year number.
Why it fails
The method can describe the task correctly, but it repeats the same pattern and hides the general structure of the solution.
Do this instead
Identify the repeated group of operations and place it once inside a loop body governed by a counter.
Common mistake
Placing an operation outside the loop body when it belongs to the repeated process
What it looks like
Putting the counter update after the closing brace so it runs only once or never.
Why it fails
The source states that the complete repeated process must be inside the loop body. An update outside the body is not part of each iteration.
Do this instead
Check that every yearly operation, including the counter update, sits between the loop's opening and closing braces.
Common mistake
Forgetting to initialize the counter
Why it fails
The loop's starting point is then unintended, so the number of passes and the first value of the counter may not match the algorithm.
Do this instead
Set the counter to its starting value before the loop begins.
Common mistake
Assuming the program is correct because it compiles or runs
Why it fails
A semantic error runs without complaint. The output can look plausible while the algorithm is wrong.
Do this instead
Compare the program's behavior with the refined steps and check the output for each pass.

Practice Tracing a Loop

MEDIUM

A loop is meant to display the value of an investment for years 1 through 3. Its counter is initialized to 0, the check is year less than 3, and the increment and display steps are inside the body. Trace the first two passes and list the values of year and the display output. Then say whether the loop stops after three displays, and explain which of the four debugging questions your answer depends on.

Hints

Write the value of year before the check on each pass, then the value after the increment.
Remember that the check is made before each pass, so the body runs only while the check is true.
The four questions are about initialization, change, the stopping condition, and loop body membership.

Your attempt (not saved)

EASY

Take a loop with a correct counter and body but a condition that is written as year less than or equal to 2 instead of year less than 3. Predict how many displays appear, then state which step of the algorithm diverges from the intended result.