Trace Tables and Debugging

Trace tables

A trace table records the value of every variable after each step of an algorithm. It is how you find out what code really does, as opposed to what you think it does, and it is a standard question on every GCSE paper.

The method never changes:

1. One column for each variable, plus one for the output
2. One row for each pass of a loop, or each time a variable changes, working strictly in program order
3. Write the value a variable has after the pass, and put a dash in a box only if the variable does not have a value yet

Worked example 1: a loop

total = 0
for i in range(1, 5):
    total = total + i * 2
    print(i, total)

The loop runs for 1, 2, 3 and 4. It does not run for 5, because range stops before its second value.

Worked example 2: a while loop with MOD and DIV

number = 4721
total = 0
while number > 0:
    digit = number % 10
    total = total + digit
    number = number // 10
    print(digit, total, number)
print("Digit sum:", total)

number % 10 peels off the last digit and number // 10 throws it away. When number reaches 0 the test number > 0 is false and the loop ends. Notice that the last row has number equal to 0 and yet the digit of that row is 4, because the loop body ran once more with number still 4 before it was cut to 0.

Finding the purpose

Often the question does not ask for the table. It asks what the algorithm does. Trace it with small numbers and then describe the result, not the steps.

a = 48
b = 18
while b != 0:
    temp = b
    b = a % b
    a = temp
print(a)

It prints 6, which is the highest number that divides both 48 and 18. The algorithm finds the highest common factor of two numbers. It is more than 2,000 years old and is named after Euclid.

Finding and fixing errors

The exam gives you an algorithm that does not work, asks you to find the error, and asks for the corrected line. Nearly all of them are one of these:

Six faults, each one running

An off by one error. The aim is 1 to 5:

for i in range(1, 5):
    print(i, end=" ")        # 1 2 3 4: the 5 is missing
print()
for i in range(1, 6):
    print(i, end=" ")        # 1 2 3 4 5
print()

A total reset in the wrong place. The aim is the average of three marks:

marks = [50, 60, 70]

total = 0
for mark in marks:
    total = 0                # fault: this wipes out the running total
    total = total + mark
print(total / len(marks))    # 23.333333333333332

total = 0
for mark in marks:
    total = total + mark
print(total / len(marks))    # 60.0

A return inside the loop. The aim is to add every number:

def total_of(numbers):
    total = 0
    for n in numbers:
        total = total + n
        return total         # fault: leaves the function on the first pass
    return total

print(total_of([1, 2, 3]))   # 1

The return must line up with the for, so it runs once the loop has finished. Move it left by one level and the answer is 6.

A starting value that is wrong. The aim is the largest number:

numbers = [-4, -9, -2, -7]

largest = 0
for n in numbers:
    if n > largest:
        largest = n
print(largest)               # 0, which is not even in the list

largest = numbers[0]
for n in numbers:
    if n > largest:
        largest = n
print(largest)               # -2

A type error. Text and numbers cannot be joined with a plus:

# raises: TypeError
score = 7
print("Score: " + score)

The fix is print("Score: " + str(score)), or print("Score:", score).

An assignment where a comparison was meant:

# raises: SyntaxError
score = 7
if score = 7:
    print("Seven")

Python catches this one before it runs and says Maybe you meant '==' instead of '='. A logic error you have to find yourself, and a syntax error the computer finds for you.

Debugging tools and techniques

Debugging is finding out why a program is wrong. The tools and habits below are in the specification, and they work in this order.

Read the error message

The last line names the error and the line above it gives the position. Python's messages are written to be read.

Print to see inside

The most common technique, and the one professionals still use first: print a variable at the point you are unsure about.

def average(marks):
    total = 0
    for mark in marks:
        total = total + mark
        print("added", mark, "total is now", total)
    return total / len(marks)

print(average([50, 60, 70]))

Test small, test early

Run each subprogram on its own with values you can work out in your head, before you build the next one on top of it.

Check with assert

assert states something that must be true. If it is not, the program stops at that exact line and says so, which is far better than a wrong answer appearing three screens later.

def grade_for(mark):
    if mark >= 70:
        return "Distinction"
    elif mark >= 50:
        return "Merit"
    return "Fail"

assert grade_for(70) == "Distinction"
assert grade_for(69) == "Merit"
assert grade_for(50) == "Merit"
assert grade_for(49) == "Fail"
print("All four tests passed")

What an IDE gives you

An integrated development environment puts the tools in one program. The exam names these:

Key terms you must be able to define

Trace table

A table that records the value of each variable after every step of an algorithm.

Dry run

Working through an algorithm by hand, without running it, to check what it will do.

Debugging

Finding and fixing faults in a program.

Syntax error

A mistake in the rules of the language, which stops the program from running.

Logic error

A mistake that lets the program run but produces the wrong result.

Breakpoint

A point in a program where a debugger pauses it, so the programmer can inspect it.

Variable watch

A debugging tool that shows the current value of chosen variables as the program runs.

Off by one error

A fault where a loop or an index is one too many or one too few.

IDE

Integrated development environment: a program that combines an editor, translator and debugging tools.

Flashcards

Say the definition out loud before you flip the card. Retrieving it from memory is what builds recall, reading it again is not.

Reach the top grade on this topic

Tracing questions are the most reliably gained marks on the paper, and the most reliably thrown away.

• Give every variable its own column, and write each row in the order the program runs
• Trace with the exact numbers you were given, never with ones you invent
• State the purpose of an algorithm as a result: highest common factor, total, count, maximum
• When asked to correct an error, name the line, write the fixed line, and say what it now does
• Name the IDE tool and what it does: a breakpoint pauses, a watch shows a value

Mistakes that cost marks here

x = 1
y = 10
while y > 4:
    x = x * 2
    y = y - 3
print(x)

a = 48
b = 18
while b != 0:
    temp = b
    b = a % b
    a = temp
print(a)

numbers = [-4, -9, -2, -7]
largest = 0
for n in numbers:
    if n > largest:
        largest = n
print(largest)

score = 7
if score = 7:
    print("Seven")