Debug

Overview

Based on "The Pragmatic Programmer" by Andrew Hunt & David Thomas. Hunt & Thomas's debugging philosophy: debugging is a puzzle to be solved with evidence, not a crisis to be panicked through. The key discipline is don't guess. Form a hypothesis, predict what you'll see if the hypothesis is correct, test it, and observe. Repeat.

Their rubber duck principle: before asking for help, explain the problem out loud (to a rubber duck or anyone). The act of articulating often reveals the answer.

Workflow

Step 1: Reproduce the bug reliably

You cannot debug what you cannot reproduce.

• What exact steps produce the bug? Document them.
• Is it 100% reproducible or intermittent?
• On which environments? (dev only, staging, prod?)
• Since when? (what changed recently?)

If you can't reproduce it reliably, make that the first problem to solve.

Step 2: Understand the expected vs actual behavior

State explicitly:

• Expected: what should happen?
• Actual: what is happening?
• Evidence: logs, error messages, screenshots

Do not skip this. Vague bug descriptions lead to fixing the wrong thing.

Step 3: Form a hypothesis

What is your best theory for why the actual differs from expected? Write it down. Debugging without a hypothesis is random exploration.

Step 4: Predict the evidence

If your hypothesis is correct, what will you see when you look at [specific thing]? Make a prediction before you look. This keeps you honest.

Step 5: Test the hypothesis

• Add targeted logging or use a debugger to observe the predicted evidence
• Change one thing at a time - not multiple
• If the evidence matches: hypothesis confirmed, move to Step 6
• If the evidence doesn't match: your hypothesis is wrong, go back to Step 3

Step 6: Fix the root cause (not the symptom)

Hunt & Thomas: fix the problem, not the symptom.

• Symptom fix: catching an exception that shouldn't be thrown
• Root cause fix: understanding why the exception is thrown and preventing it

Ask "why" five times before writing the fix.

Step 7: Verify the fix

• Does the original reproduction case pass?
• Do existing tests still pass?
• Write a test that would have caught this bug originally

Step 8: Document the learning

What was the root cause? What made it hard to find? How could it be caught earlier next time?

Anti-Patterns

1. Guessing instead of hypothesizing Bad: Randomly changing things until it works. Good: Form a hypothesis. Predict evidence. Test. Observe. Either confirm or refute.

2. Fixing the symptom Bad: Adding a null check to stop the crash. Good: Understanding why null is reaching that point and preventing it at the source.

3. Changing multiple things at once Bad: "Let me try these 5 changes together." Good: One change at a time. Otherwise you don't know which change fixed it.

4. Not writing a regression test Bad: Fix the bug, move on. Good: Write a test that reproduces the bug before fixing it. The test passes after the fix. It lives in the suite forever.

Quality Checklist

• Bug is reproducible with documented steps
• Expected vs actual behavior stated explicitly
• Hypothesis written down before testing
• Evidence predicted before looking
• One change at a time during investigation
• Root cause identified (not just symptom)
• Fix verified against original reproduction case
• Regression test written