Foundations
Debugging by Tracing
Difficulty: Beginner
Most beginners debug by staring at their code and hoping the bug reveals itself. Engineers who ship working software do something different: they trace execution one line at a time, watch each variable, and pinpoint the exact moment the...
Debugging by Tracing
Most beginners debug by staring at their code and hoping the bug reveals itself. Engineers who ship working software do something different: they trace execution one line at a time, watch each variable, and pinpoint the exact moment the program's state stops matching their mental model. That motion is a learnable, repeatable skill.
Debugging by Tracing turns that skill into a structured workflow. You will define what program state actually is (the values of every variable plus the current line of execution), practice walking through a function step by step recording each change, and learn to use loop invariants (conditions that must hold before and after every iteration) to verify correctness without running the code. You will work through a systematic process of reproduce, trace, locate, fix, and verify, and you will see the most common beginner pitfalls including off-by-one errors, uninitialized variables, and misordered swaps.
In How to Read Code (JS & Python), you practiced tracing variables through for and while loops and stepping through function calls on the call stack. This lesson takes that same tracing motion and aims it at a specific goal: finding the line where a bug first introduces wrong state, instead of just understanding what correct code is doing.
With Tier 1 essentials behind you, you will be ready to dive into the data structures track starting with Arrays & Strings, where every algorithm you write will benefit from being traceable and provably correct.
Prerequisites:
Algorithms and EfficiencyTopics:
What You'll Learn
By the end of this lesson, you will be able to:
Define program state and explain why tracking it matters for debugging.
Trace a short program step by step, recording variable values after each line.
Identify the exact line where actual output diverges from expected output.
Explain what a loop invariant is and verify one on a simple loop.
Apply a systematic debugging process: reproduce, trace, locate, fix, verify.
Recognise common beginner mistakes such as off-by-one errors and uninitialised variables.
Why This Matters
01
Bugs are inevitable; the ability to trace code and locate the exact line where things go wrong separates productive developers from frustrated ones.
02
Tracing is the foundation of all debugging strategies, from adding print statements to using a step-through debugger.
03
Understanding invariants lets you reason about correctness before you even run the code, which is essential for writing algorithms that work the first time.
Key Terms
7 terms you'll encounter in this lesson
Program state
The complete set of variable values and the current execution point at a given moment during a program's run.
Tracing
Manually stepping through code line by line, recording how each variable changes, to understand or debug the program's behaviour.
Invariant
A condition that is always true at a specific point in the program, such as the start or end of every loop iteration.
Loop invariant
A property that holds before the first iteration and is maintained by every iteration of a loop. Useful for proving correctness.
Off-by-one error
A bug where a loop runs one time too many or too few, often caused by using < instead of <= or starting at the wrong index.
Dry run
Another name for tracing: executing code in your head or on paper without actually running it on a computer.
Breakpoint
A marker set in a debugger tool that pauses execution at a specific line so you can inspect variable values.
Related Problems
Coding problems that put this lesson's concepts into practice
Heads Up
Common misconceptions to watch out for
"Debugging means staring at the code until the bug jumps out"
Random staring is slow and unreliable. Systematic tracing narrows the search to the exact line where state diverges from expectation.
"If the output is wrong, the bug must be on the last line"
The wrong value can originate many lines earlier. Tracing from the top reveals where state first goes wrong, which may be far from where the symptom appears.
"Adding print statements everywhere is the best debugging strategy"
Print statements help, but without a mental model of expected state at each point, you cannot interpret the output. Trace first, then add targeted prints to confirm your hypothesis.
"Invariants are only for math proofs, not for real coding"
Invariants are practical: thinking 'after iteration i, the sum should equal the total of the first i elements' instantly tells you whether a loop is correct.