Purpose and Overview

Learning Objectives

1. 1Explain why programming mistakes are inevitable and describe the right attitude toward them.
2. 2Define and distinguish syntax errors, runtime errors, and logic errors.
3. 3Identify common examples of each error category in Python-style programs.
4. 4Read and interpret Python error messages and tracebacks.
5. 5Apply a toolkit of debugging strategies including hand tracing, print debugging, and assumption checking.
6. 6Design deliberate test cases with specific inputs and expected outputs.
7. 7Identify edge cases for a given function and explain why they matter.
8. 8Describe the incremental development approach and explain why it reduces debugging difficulty.
9. 9Write useful comments and docstrings for functions and programs.
10. 10Apply program design thinking before and during writing code.

Sections at a Glance

• 10.1Mistakes Are Part of ProgrammingWhy mistakes are inevitable; the gap between intention and instruction; complexity and invisible assumptions; the right attitude toward debugging
• 10.2Syntax ErrorsWhat syntax errors are; how they are detected; missing colons, mismatched parentheses, indentation problems, keyword misspellings; fixing strategies
• 10.3Runtime ErrorsWhat runtime errors are; ZeroDivisionError, IndexError, NameError, TypeError, FileNotFoundError; why runtime errors are more challenging than syntax errors
• 10.4Logic ErrorsWhat logic errors are; off-by-one errors, wrong operators, wrong variables, missing updates, incorrect formulas; why logic errors are the hardest category
• 10.5Reading Error MessagesAnatomy of a Python error message; reading tracebacks from the bottom up; common error type names; when the reported line is not the real source
• 10.6Debugging StrategiesRead slowly; hand tracing with tables; print debugging; simplify the problem; check assumptions; work backward from wrong output; take a break
• 10.7Test CasesWhat a test case is; designing test cases before running; test tables with input and expected output; the difference between testing and running
• 10.8Edge CasesWhy edge cases matter; empty input, single-element input, boundary values, negative values, large values, repeated values; worked boundary example
• 10.9Incremental DevelopmentWrite a little, test it, then write more; why the alternative fails; step-by-step worked example; maintaining a working version at all times
• 10.10Documentation and Program DesignComments, docstrings, and external docs; writing useful vs. redundant comments; naming as design; program design questions before coding; the connection to debugging

Mistakes Are Part of Programming

Where Mistakes Come From

Syntax Errors

Common Syntax Errors

if score > 90
    print("Excellent")

if score > 90:
    print("Excellent")

result = (3 + 4 * 2

result = (3 + 4 * 2)

if temperature > 100:
print("Very hot")

if temperature > 100:
    print("Very hot")

Runtime Errors

Common Runtime Errors

Logic Errors

Common Logic Errors

for i in range(10):
    print(i)

if score > 60:
    print("Pass")

total = 0
count = 0
for value in scores:
    total = total + value
    count = count + 1
average = total / total   # Should be: total / count

largest = scores[0]
for score in scores:
    if score > largest:
        pass   # Forgot: largest = score
print("Largest:", largest)

Reading Error Messages

Anatomy of a Python Error Message

Traceback (most recent call last):
  File "grades.py", line 14, in calculate_average
    average = total / count
ZeroDivisionError: division by zero

Debugging Strategies

Strategy 1: Read the Code Carefully and Slowly

Strategy 2: Trace the Program by Hand

Strategy 3: Add Print Statements

def calculate_average(scores):
    total = 0
    count = 0
    for score in scores:
        total = total + score
        count = count + 1
        print(f"  After adding {score}: total={total}, count={count}")
    print(f"Computing: {total} / {count}")
    return total / count

Strategy 4: Simplify the Problem

Strategy 5: Check Your Assumptions

Strategy 6: Work Backward from Wrong Output

Strategy 7: Take a Break

Test Cases

Edge Cases

Incremental Development

Documentation and Program Design

Forms of Documentation

Writing Good Comments

# Assign 10 to count
count = 10

# Start count at 10: the survey skips the first 10 warm-up responses
count = 10

# Guard against zero before dividing to prevent ZeroDivisionError
if count > 0:
    average = total / count

Writing Docstrings

def calculate_average(scores):
    """
    Calculate and return the arithmetic mean of a list of numbers.

    Parameters:
        scores: a list of numbers (may be empty)

    Returns:
        The arithmetic mean of the values in scores.
        Returns 0.0 if the list is empty.
    """
    if len(scores) == 0:
        return 0.0
    return sum(scores) / len(scores)

Naming as a Form of Design

Program Design Questions Before Coding

Chapter Summary

• Sec 10.1Mistakes are normal and inevitable. The gap between intention and instruction is where almost every programming error lives. Debugging is a skill: the right attitude is curiosity, not frustration.
• Sec 10.2Syntax errors violate the grammar rules of a programming language. They are caught before the program runs and must be fixed before execution can begin. Common causes: missing colons, unmatched delimiters, bad indentation, misspelled keywords, unclosed strings.
• Sec 10.3Runtime errors occur during execution when a syntactically correct operation cannot be completed. They depend on conditions and produce exceptions. Common types: ZeroDivisionError, IndexError, NameError, TypeError, FileNotFoundError.
• Sec 10.4Logic errors are mistakes in reasoning. The program runs without crashing but produces wrong output. No error message is produced. Logic errors require testing and careful tracing to find. Common examples: off-by-one errors, wrong operators, wrong variables, missing loop updates.
• Sec 10.5Error messages and tracebacks contain real information. Read them carefully. For tracebacks, read from the bottom up — the actual error type and description is always at the bottom. The reported line may not always be the true source of the error.
• Sec 10.6Seven debugging strategies: read slowly; trace by hand; add print statements; simplify the problem; check your assumptions; work backward from wrong output; take a break. These strategies work together and apply to every level of programming.
• Sec 10.7A test case is a specific input paired with its expected output. Design test cases before running the program when possible. Running a program once is not testing. Systematic test cases build justified confidence in a program's correctness.
• Sec 10.8Edge cases test boundaries and extremes: empty collections, single elements, boundary values, negative numbers, very large values, all-same values. Edge cases reveal the hidden assumptions a program makes and the bugs those assumptions can cause.
• Sec 10.9Incremental development means writing small pieces and testing each one before adding more. It keeps bugs small and isolated. Writing all the code before testing is far less efficient because the debugging time at the end outweighs the saved testing time during development.
• Sec 10.10Documentation makes programs understandable. Useful comments explain reasoning, not just what the code does. Docstrings describe function purpose, parameters, and return values. Naming is design. Thinking about structure, inputs, outputs, and edge cases before writing code makes everything afterward easier.

Key Terms Review

Error Classification Practice

For each description, identify the error type: syntax error, runtime error, or logic error. Explain your answer in one sentence.

1. A program is supposed to print the numbers from 1 to 5. It prints 0, 1, 2, 3, 4.
2. Python refuses to run a program and reports SyntaxError: expected ':' on line 6.
3. A program calculates a shopping discount. When the discount is 100%, it crashes with ZeroDivisionError.
4. A function is supposed to return the second item in a list. It always returns the first item.
5. Python reports NameError: name 'total' is not defined when the program runs.
6. A temperature conversion function produces results that are off by a fixed amount for every input — always 32 degrees too high.
7. Python refuses to start the program because a closing parenthesis is missing on line 12.
8. A sorting function crashes on an empty list with IndexError: list index out of range.

Debugging Scenarios

Each program below contains one error. Identify the type of error, explain what it is, and write a corrected version.

Test Case Design

For each function described below, design at least four test cases. Give the input and the expected output for each. At least one test case should be an edge case.

1. A function is_even(n) that returns True if n is even and False if it is odd.
2. A function clamp(value, minimum, maximum) that returns value if it falls between minimum and maximum, returns minimum if value is below, and returns maximum if value is above.
3. A function count_vowels(word) that returns the number of vowels (a, e, i, o, u) in a given string.
4. A function safe_divide(numerator, denominator) that returns the result of division if denominator is not zero, and returns 0.0 if it is zero.

Hand-Tracing Practice

Trace each program by hand. Create a variable-tracking table at each step. Then write the exact output the program produces.

Documentation Practice

1. The following function has no documentation and poor names. First, add a docstring and appropriate comments. Second, rename all variables and the function so the code is self-explanatory without needing to read the comments.
   def process(lst, t): r = [] for x in lst: if x >= t: r.append(x) return r
2. Write a docstring for a function send_reminder(recipient, message, days_before) that schedules a reminder email. The function returns True if the reminder was scheduled successfully and False otherwise.
3. A classmate says: "I never add comments to my code because I know what it does and I can always read it later." Write a response — at least two paragraphs — explaining why this attitude is a problem, using concrete examples.

Incremental Development Practice

A program is supposed to read a list of student names and test scores, calculate the class average, and identify which students scored above the average. Plan how to build this program incrementally.

1. Describe the first version you would write and test. What would it do? What would its output look like?
2. Describe the second version — what you would add and test next.
3. Describe the third version.
4. Continue until the full program is described. You should have at least four incremental steps total.
5. For each step, describe what test input you would use and what correct output you would expect.

Edge Case Identification

For each function described below, list at least three edge cases that good tests should cover. For each, explain what might go wrong if the code does not handle it.

1. A function that finds the second-largest value in a list of numbers.
2. A function that checks whether a given string is a palindrome (reads the same forward and backward).
3. A function that removes duplicate values from a list, preserving the order of first occurrence.
4. A function that takes a sentence as a string and returns the number of words in it.

Chapter 10 Checkpoint

Mixed Review

These questions draw on material from Chapters 5 through 10.

1. What is the difference between a parameter and an argument?
2. Write a function double_all(numbers) that takes a list of numbers and returns a new list where every value is doubled. Then design three test cases for it, including one edge case.
3. What does this program print?
   x = 10 y = 3 print(x // y) print(x % y)
4. Rewrite the following code using a function to eliminate repetition:
   print("Name:", "Alice") print("Score:", 88) print("Grade:", "B") print("---") print("Name:", "Ben") print("Score:", 72) print("Grade:", "C") print("---")
5. A program is supposed to print all even numbers from 2 to 20. A student writes:
   for i in range(2, 20): if i % 2 == 0: print(i)
   What error does this contain? What is the correct version?
6. What is the purpose of a return value in a function? Give one example where a return value is essential, and one example where a function that only produces output (with no return value) is appropriate.

Real-World Applications

1. Software in a hospital manages medication dosing. A logic error causes the program to calculate doses 10% too high. What are the potential consequences? Who bears responsibility — the programmer, the hospital, the software company? What testing requirements should apply to safety-critical medical software?
2. A navigation app calculates the wrong travel time because it does not handle road closures as an edge case. What other edge cases should the developers have anticipated for a navigation system? What kind of testing would catch these?
3. An online store's checkout program crashes when a user tries to check out with an empty cart. (a) What type of error is this? (b) What test case would have caught it during development? (c) What line of defensive code would prevent it?
4. A payroll system at a company has been running for two years. A newly hired programmer modifies the overtime calculation function. After the change, employee paychecks are slightly wrong for employees working more than 40 hours. What debugging strategies would you use? What development practices could have prevented this from reaching production?
5. Professional software development teams often require that every bug fix include a new test case specifically for the bug that was fixed. This is called a regression test. Explain what regression tests accomplish over time and why they are valuable.