Iterative Improvement

Why it matters

Every lesson in this module has led here. Reaching straight for the cleverest-looking solution combines two hard things at once — correctness and complexity — so a bug could be coming from either. Iterative improvement separates them: get something simple working and verified first, then improve it in small steps, checking correctness again after each one.

Mental model

This is the last step of the loop introduced back in problem decomposition — Understand, Model, Plan, Implement, Verify, Improve — and it has its own discipline:

1. Get a simple, obviously correct version working.
2. Verify it, ideally with the kind of assert checks from the debugging and testing lesson.
3. Improve one thing.
4. Re-run the same checks. If they still pass, the improvement was safe; if not, there’s exactly one change to suspect.
5. Repeat.

Small example

Start with has_duplicates_slow from the previous lesson — simple, easy to trust is correct — and verify it:

def has_duplicates_slow(numbers):
    for i in range(len(numbers)):
        for j in range(len(numbers)):
            if i != j and numbers[i] == numbers[j]:
                return True
    return False

assert has_duplicates_slow([1, 2, 3]) == False
assert has_duplicates_slow([1, 2, 2]) == True
assert has_duplicates_slow([]) == False

All three assertions pass — including the empty-list edge case. Now improve it, and check the exact same assertions still hold:

def has_duplicates_fast(numbers):
    seen = set()
    for number in numbers:
        if number in seen:
            return True
        seen.add(number)
    return False

assert has_duplicates_fast([1, 2, 3]) == False
assert has_duplicates_fast([1, 2, 2]) == True
assert has_duplicates_fast([]) == False

All three still pass. Because only one thing changed, and the same checks confirmed the change didn’t break anything, this improvement can be trusted.

Trace it

Check your understanding

Practice: warm-up

Starting from this verified, working function, apply one improvement — replacing the manual loop with Python’s built-in sum() — and confirm the same assertion still passes.

def total(numbers):
    result = 0
    for number in numbers:
        result = result + number
    return result

assert total([1, 2, 3]) == 6

def total(numbers):
    return sum(numbers)

assert total([1, 2, 3]) == 6   # still passes — the improvement was safe

Practice: apply it

A teammate “improved” a verified function by changing three things at once — adding an empty-list check, introducing a new count variable, and rounding the result — and now an existing regression test fails. (round(value, 2) rounds to 2 decimal places — new syntax, but readable from its name.)

def average(numbers):
    if not numbers:
        return 0.0
    total = sum(numbers)
    count = len(numbers)
    return round(total / count, 2)

assert average([1, 2, 4]) == 2.3333333333333335

The original, verified version only computed sum(numbers) / len(numbers), with no rounding and no empty-list check — and that exact, unrounded value is what the existing test expected.

Modification challenge: starting from the original verified version, reapply the three changes one at a time, re-running assert average([1, 2, 4]) == 2.3333333333333335 after each, to confirm the rounding step is exactly the one that breaks it.

Summary

• Get a simple, obviously correct solution working and verified first — before making it faster, shorter, or more elegant.
• Improve one thing at a time, and re-run the same checks after each change.
• A failing check after a single change points at exactly one suspect; after several at once, it doesn’t.
• This closes the loop this module opened with: Understand, Model, Plan, Implement, Verify, Improve.