Debugging: Fixing Programs

In the previous chapter we discussed data structures.

Now we address something every programmer faces daily:

bugs.

Programming is not writing perfect code once. It is writing, testing, finding issues, and improving.

---

What Is a Bug?

A bug is any behavior where the program does not do what it should.

Common categories:

• syntax errors: code is not valid language syntax
• runtime errors: code runs, then crashes or throws exceptions
• logic errors: code runs without crashing but gives wrong results

All three are normal parts of development.

---

A Practical Debugging Workflow

A useful process:

1. Reproduce the issue reliably.
2. Narrow scope to the smallest failing case.
3. Inspect relevant variables and control flow.
4. Form a hypothesis.
5. Apply a fix.
6. Re-test and verify no regression.

This beats random trial-and-error changes.

---

Reading Error Messages

Error messages are often dense, but they contain key signals:

• file and line number
• error type
• failing operation
• call stack context

Instead of ignoring errors, treat them as guidance.

Even experienced developers rely heavily on stack traces.

---

Debugging Tools and Techniques

Common techniques:

• print/log statements
• step-through debugger
• breakpoints and variable watches
• unit tests for isolated behavior

For beginners, careful logging plus small test cases is often enough to solve most issues.

---

Testing and Confidence

Debugging fixes current problems.

Testing prevents old problems from returning.

A simple test suite gives confidence that changes do not break existing features.

graph LR
  A[Write Code] --> B[Run Program]
  B --> C[Find Bug]
  C --> D[Fix]
  D --> E[Add Test]
  E --> F[Safer Future Changes]

---

Debugging Mindset

Two habits matter most:

• Stay systematic.
• Assume your first guess may be wrong.

Bugs are not a sign you are failing. Debugging is part of the craft.

---

Key Ideas to Remember

• Bugs are expected in real development.
• Error types include syntax, runtime, and logic issues.
• Systematic debugging is faster than random edits.
• Error messages and stack traces are valuable signals.
• Tests help prevent repeated failures.

---

What Comes Next

So far we focused on code-level building blocks.

Now we zoom out:

how many programs, modules, and tools combine into real software products.