Debugging Techniques

Debugging demands active practice because students learn best by engaging with real errors and tools, not just reading about them. This topic sticks when students repeatedly confront bugs, test fixes, and explain their process aloud.

• 11th Grade
• Computer Science
• 4 activities
• 20 min–35 min

Learning Objectives

1. Identify common syntax and runtime errors in provided code snippets.
2. Explain the purpose and functionality of a debugger's step-through, breakpoint, and watch features.
3. Analyze a complex program to isolate the root cause of a reported bug.
4. Construct a reproducible test case for a given software defect.
5. Evaluate the effectiveness of different debugging strategies for a specific problem.

Think-Pair-Share

⏱ 25 min·Pairs

Think-Pair-Share: Bug Hunt

Each student receives a short buggy program and independently identifies what is wrong and why, without running the code. Partners then compare their diagnoses and reasoning before sharing with the class to surface the range of diagnostic approaches used.

Prepare & details

Explain common debugging strategies and tools.

Facilitation Tip: During Bug Hunt, ask students to first read errors silently for 30 seconds before discussing, to build careful reading habits.

Setup: Standard classroom seating; students turn to a neighbor

Materials: Discussion prompt (projected or printed), Optional: recording sheet for pairs

• Understand
• Apply
• Analyze
• Self-Awareness
• Relationship Skills

Role Play

⏱ 20 min·Pairs

Role Play: Rubber Duck Debugging

Students explain their code line-by-line to a partner who acts as a 'rubber duck': they may only ask clarifying questions and may never suggest fixes. The explainer must articulate what each line does and what they expect, often locating bugs in the process of explaining.

Prepare & details

Analyze complex code to identify the root cause of a bug.

Facilitation Tip: When students role-play Rubber Duck Debugging, require them to speak in complete sentences, modeling how to externalize thought processes.

Setup: Open space or rearranged desks for scenario staging

Materials: Character cards with backstory and goals, Scenario briefing sheet

• Apply
• Analyze
• Evaluate
• Social Awareness
• Self-Awareness

Gallery Walk

⏱ 35 min·Small Groups

Gallery Walk: Annotated Bug Reports

Groups post printed buggy code samples with their initial hypothesis and debugging notes. Other groups tour the gallery, add sticky-note hypotheses of their own, and flag where they agree or disagree with the posted diagnosis.

Prepare & details

Construct a systematic approach to debugging a given software problem.

Facilitation Tip: For the Gallery Walk, have students annotate bug reports with colored sticky notes to highlight key clues they noticed.

Setup: Wall space or tables arranged around room perimeter

Materials: Large paper/poster boards, Markers, Sticky notes for feedback

• Understand
• Apply
• Analyze
• Create
• Relationship Skills
• Social Awareness

Structured Academic Controversy

⏱ 30 min·Pairs

Structured Academic Controversy: Best Debugging Strategy

Present two debugging approaches (print-statement tracing vs. interactive debugger with breakpoints) and assign pairs to argue for each strategy. Pairs switch positions, argue the opposing view, then synthesize a recommendation that accounts for context and trade-offs.

Prepare & details

Explain common debugging strategies and tools.

Facilitation Tip: During the Structured Academic Controversy, assign roles explicitly so students practice defending one strategy before synthesizing the best approach together.

Setup: Pairs of desks facing each other

Materials: Position briefs (both sides), Note-taking template, Consensus statement template

• Analyze
• Evaluate
• Create
• Social Awareness
• Relationship Skills

Teaching This Topic

Teach debugging like a protocol, not a talent. Model your own thought process aloud when errors occur in front of the class, showing how to pause, hypothesize, and test. Avoid letting students feel shame around bugs; instead, celebrate the moment a bug is found and fixed. Research shows that students learn debugging faster when they work in pairs and explain their reasoning to peers.

What to Expect

Students will move from random guesses to structured diagnosis by reading error messages, using debuggers, and documenting their steps clearly. By the end, they should articulate their debugging strategy before changing any code.

Watch Out for These Misconceptions

Common Misconception

During Bug Hunt, watch for students who glance at errors and immediately guess fixes without reading the full message.

What to Teach Instead

Require students to copy the error message verbatim and circle key terms before discussing, using the activity’s printed script sheets to ground their observations.

Common Misconception

During Rubber Duck Debugging, watch for students who rush to fix the bug without explaining their process aloud first.

What to Teach Instead

Use a timer to enforce full explanations, then ask the ‘duck’ to repeat the explanation in their own words to confirm understanding.

Common Misconception

During Gallery Walk, watch for students who focus only on syntax errors and ignore logic or runtime issues in the bug reports.

What to Teach Instead

Provide a prompt card asking them to categorize each bug type before annotating, using the gallery’s printed error categories as a scaffold.

Assessment Ideas

Quick Check

After Bug Hunt, give students a new Python script with a syntax error and ask them to use the debugger to identify the line and explain the error in writing before fixing it.

Discussion Prompt

During Structured Academic Controversy, ask groups to present their chosen debugging strategy and justify it with examples from their own debugging experiences.

Peer Assessment

After the peer debugging task, partners exchange written reflections on the debugging process they used, noting what worked and what they would try differently next time.

Extensions & Scaffolding

• Challenge: Provide a buggy script with intermittent failures. Ask students to write a test case that reliably reproduces the bug before fixing it.
• Scaffolding: Give students a short checklist of debugging steps (e.g., read error, check input, add print statements) to follow for the first two bugs they encounter.
• Deeper exploration: Introduce conditional breakpoints in the debugger and ask students to track how they narrow down a logic error in a longer program.

Key Vocabulary

Bug	An error, flaw, or fault in a computer program or system that causes it to produce an incorrect or unexpected result, or to behave in unintended ways.
Debugger	A computer program used to test and debug other programs. It allows developers to examine code execution, set breakpoints, and inspect variables.
Breakpoint	A point in a program's execution where the debugger will pause execution. This allows inspection of the program's state at that specific moment.
Stack Trace	A report of the set of nested function calls that are currently active. It shows the sequence of function calls that led to the current point of execution or error.
Reproducibility	The ability to consistently recreate a specific bug or error by following a defined set of steps.