Debugging: Finding Why Things Broke

From Bee: Read the LAST line of the error first. That is the actual error. The lines above it are just the path the program took to get there.

What Is Debugging?

Debugging is figuring out why code didn't do what you expected, then fixing it. The skill is forming a hypothesis ("I think the variable is undefined when this runs"), testing it (print the variable, run again), and iterating.

Read the Error Message

Beginners often ignore error messages because they look scary. They're not — they tell you exactly what's wrong and on which line. Read the last line first (the actual error), then the line numbers above it (the path of how you got there).

Print Debugging

The simplest, most underrated technique: add console.log / print at suspect points to see what variables actually contain. Yes, professional debuggers exist; no, they're not always faster than print.

Binary Search the Bug

If a 100-line function is broken, comment out the bottom half — does the bug still appear? If yes, the bug is in the top half. Cut that half in half. Repeat. You'll find the line in ~7 cuts.

Spot the Bug

A new buggy snippet every time. Click the line you think is wrong.

Code Examples in Three Languages

// Print debugging
function calculate(items) {
  console.log("items:", items);
  let total = 0;
  for (const item of items) {
    console.log("processing:", item);
    total += item.price;
  }
  console.log("final total:", total);
  return total;
}

// Browser DevTools also lets you set breakpoints
// Press F12, go to Sources, click a line number

# Print debugging
def calculate(items):
    print("items:", items)
    total = 0
    for item in items:
        print("processing:", item)
        total += item["price"]
    print("final total:", total)
    return total

# Use the built-in debugger
import pdb; pdb.set_trace()  # pauses execution here

// Print debugging
public static int calculate(List<Item> items) {
    System.out.println("items: " + items);
    int total = 0;
    for (Item item : items) {
        System.out.println("processing: " + item);
        total += item.price;
    }
    System.out.println("final total: " + total);
    return total;
}

// IDEs (IntelliJ, Eclipse) provide rich debuggers

Best Practices

1. Reproduce reliably first. A bug you can reproduce on demand is half-fixed.
2. Change one thing at a time. Otherwise you don't know what fixed it.
3. Read the stack trace top-to-bottom. Find the first line in your code.
4. Rubber-duck it. Explain the code aloud to an inanimate object — bugs often surface in the explanation.
5. Take breaks. Bugs that vanish after a walk are real.

Common Mistakes

• Assuming the error message is wrong. It almost never is.
• Changing things "to see what happens." Form a hypothesis first.
• Skipping the simplest possibility. Did you save the file? Restart the server?
• Not using version control. Without it, "I'll just try this" can lose hours of work.

How It Works Under the Hood

A debugger is a privileged program that controls another program's execution. It can pause at a line (breakpoint), inspect memory, change variables, and resume. Modern debuggers attach via the language's debug API (V8's Inspector Protocol, Python's pdb, JVM's JDI).

A stack trace is a snapshot of the call stack at the moment of the error: the chain of function calls that led there. The deepest frame is the one that threw; reading top-to-bottom shows you the path. Reading bottom-up shows you the trigger.

"Print debugging" still works because logs are reproducible. A debugger session is ephemeral; printed logs persist and can be diffed across runs. Both are valid; the right tool depends on whether the bug is local (debugger wins) or distributed (logs win).

From Beginner to Pro

The same concept gets deeper as you grow. Here's what mastery looks like at three levels:

Performance & Gotchas

• Changing two things at once — you don't know which fix mattered.
• Debugging on production data — corruption + lost reproduction.
• Forgetting to remove debug logs — leaked secrets in prod logs.
• "Works on my machine" — reproduce in a clean container before declaring done.

Quick Quiz

Real-World Uses (Production Code, Today)

Frequently Asked Questions

Related Concepts