Finding bugs when nothing crashes

When the answer is just wrong

A bug is any way a program does something other than what you meant. Some bugs stop the program with an error, and the errors lesson showed you how to read those. This lesson is about the quiet kind: no error, no warning, just a wrong answer.

Here's one. It should give the average of a week of order totals:

orders = [120, 80, 95, 140, 60, 110, 75]

total = 0
for amount in orders:
    total = total + amount
average = total / 6

print("average order:", round(average, 2))

It prints a number, and the number looks believable. That's what makes quiet bugs dangerous. The week has 7 days, but the code divides by 6, so the average comes out too high.

Debugging is a method, not a talent. The method has four steps, and the rest of this lesson takes them one at a time:

1. Say exactly what you expected, and what happened instead.
2. Make the bug happen every time.
3. Look at what the program really does, one line at a time.
4. Change one thing, then check again.

Step 1: expected against actual

"It doesn't work" is too vague to fix. "I expected 97.14 and got 113.33" is a lead. To get the expected value, work out a small case by hand, or with a calculator. Seven orders adding up to 680 should average 680 ÷ 7, about 97.14.

Once you know both numbers, the size of the gap is a clue. 113.33 is exactly 680 ÷ 6, which points straight at the division.

Tip: test with tiny, easy inputs first. With orders of 10, 20 and 30, you know the average is 20 without a calculator, so a wrong answer jumps out.

total = 0
for n in range(1, 5):
    total = total + n
print(total)

Step 2: look inside with labeled prints

You can't see variables while a program runs, so make it tell you. A print inside a loop shows each step. The = trick in an f-string prints a variable's name and its value together:

stock = [12, 0, 7, 3]
low = []
for count in stock:
    print(f"{count=}")
    if count > 0 and count < 5:
        low.append(count)
print(f"{low=}")

Now the program shows its own working. Labeled prints beat bare ones: a column of numbers is easy to misread, while count=0 can't be confused with anything else. Take them out, or comment them out, once the bug is fixed.

The step-through view does the same job without changing your code. It runs the program a line at a time and shows every variable. The next figure has a bug in it. See if you can catch the line where it goes wrong.

prices = [4, 6, 10]
for p in prices:
    total = 0
    total = total + p
print("basket:", total)

Step 3: the usual suspects

Most quiet bugs are one of a handful of slips. Check these first:

• Off by one. range(1, 5) stops at 4. len(items) is one more than the last index.
• > against >=. "Orders of 100 or more get free shipping" needs >= 100. With > 100, an order of exactly 100 misses out.
• A line in the wrong block. An indent too many puts a line inside a loop or an if. One too few takes it out.
• Text that looks like a number. "10" < "9" is True, because text is compared letter by letter, and "1" comes before "9". Convert with int() before comparing.
• The wrong order of checks. In an if/elif chain, only the first true branch runs. A general test placed before a specific one swallows it.

print("10" < "9", 10 < 9)

Step 4: make it happen every time

A bug that shows up one run in six is maddening. You change something, it seems fixed, and it was luck. Random numbers are the usual reason. This dice game crashes now and then:

import random

random.seed(4)
faces = ["one", "two", "three", "four", "five", "six"]
for turn in range(5):
    roll = random.randint(1, 6)
    print(turn, faces[roll])

random.seed(4) makes the "random" numbers come out the same on every run. Now the crash is reliable, and you can study it. The roll of 6 asks for faces[6], but a six-item list stops at index 5. Either roll randint(0, 5), or use random.choice(faces), which can't miss.

Remove the seed once it's fixed, so the game is random again.

import random

faces = ["one", "two", "three", "four", "five", "six"]
rolls = []
for turn in range(30):
    roll = random.randint(1, 6)
    rolls.append(faces[roll])

def label(n):
    if n % 3 == 0:
        return "Fizz"
    elif n % 5 == 0:
        return "Buzz"
    elif n % 15 == 0:
        return "FizzBuzz"
    return str(n)

for n in [3, 5, 15, 7]:
    print(n, label(n))

Change one thing at a time

When you find a suspect, change only that, and run again. If you change three things at once and the bug goes away, you don't know which change fixed it, or whether another one broke something new.

When a fix works, test a few more inputs, especially the edges: 0, 1, the smallest and largest values, exactly-on-the-line values like 100 for a "100 or more" rule. Bugs live at the edges.

You'll learn a fuller method, with tests that catch bugs automatically, in the software engineering phase. This one is enough for most bugs you'll meet.