Chapters Notes: Identifying and Correcting Errors | AP Computer Science Principles - Grade 9 PDF Download

Introduction

This chapter focuses on identifying and correcting errors in programming, a key skill for the AP Computer Science Principles exam and the Create task. Errors, or bugs, are common in coding and happen to all programmers, from beginners to professionals. Learning to debug effectively is essential, as it helps ensure programs work as intended. This guide covers types of errors, methods to detect and fix them, testing strategies, and an example of error correction relevant to the AP exam.

Common Coding Errors

Errors in programming are known as bugs and can be of different types:

Syntax Errors

• A syntax error happens when you break the rules of a programming language, such as missing punctuation or misspelling a keyword. 
  • For instance, forgetting a closing parenthesis or failing to indent code properly can stop your program from running. 
    
• ​These errors are frustrating but often easy to fix because modern code editors, like Visual Studio Code, highlight them (e.g., a red parenthesis for an unmatched one).
  • Example: If you write a line of code without a closing parenthesis, the program won’t run until you add it.

Logic Errors

• Happen when the program’s logic is flawed, leading to unexpected or incorrect results.
• These errors are not related to syntax or device limitations.
• Example: A multiplication program that outputs 3 × 3 = 33 instead of 9.

Run-Time Errors

• Occur while the program is running, causing it to crash during execution.
• The program starts but fails when certain conditions are met.
• Example: A division program that works until it tries to divide by zero (e.g., 5 ÷ 0), causing a crash.
• Run-time errors vary by programming language due to differences in rules and syntax.

Overflow Errors

• An overflow error occurs when a program tries to process a number too large for the system’s capacity. This typically happens when a variable exceeds the defined range of values the computer can handle.
• When an error occurs, most programming environments display an error message. For example, a syntax error might trigger a message starting with . However, error messages aren’t always clear, so you’ll need various strategies to track down and resolve bugs.

Error Fixes

Here are some proven methods to identify and correct bugs. You can combine these approaches depending on the situation.

• Test Different Inputs: Run your program with various inputs at different stages to catch errors.
• Hand Tracing: Manually track variable values step-by-step, often using a chart. This works well for simple programs, like those on the AP CSP exam, but becomes harder with complex code.
• Visualizations: Use tools to visualize code execution, which can clarify how your program runs. These aren’t required for the AP exam but can be helpful.
• Debuggers: Use specialized tools designed to find and fix bugs in your code.
• Print Statements: Add temporary  statements to check the values of variables during execution. For example, printing inputs like 5 and 7 can confirm that your input system works.

Testing

Testing ensures your program works as intended, but it’s challenging even for seasoned developers. Below are common testing challenges and best practices.

Testing Challenges

• Complexity: Longer, more complex code is harder to test thoroughly.
• Limited time and resources: Testing requires considering many failure scenarios, but time, energy, or resources may be insufficient.
• Unclear definitions: You must know the program’s requirements (what it should do) and inputs needed, or debugging becomes difficult.
• Lack of understanding: If you don’t fully understand your code, finding and fixing errors is harder.

Good Testing Practices

• Use Diverse Test Cases: Test cases include inputs and expected outputs. For example, inputs of 5 and 3 in an addition program should yield 8.
• Write Test Cases Early: Define test cases before coding to clarify your goals.
• Test Boundary Cases: Check values at the edges of your program’s limits, like 8 and 10 for a program accepting values less than 9.

Error-Hunting Example

Let’s walk through an example from the AP CSP Curriculum (CED, page 184, updated 2021). The task is to fix a program that counts how many times a value (val) appears in a list.

Problem: The program should return 2 for a list [5, 2, 3, 5] with val = 5. Here’s the flawed code:

Issue: The program resets count to 0 each time the loop iterates, so it only counts the last occurrence of val. For the test list, it returns 1 instead of 2.
Solution: Move count ← 0 outside the loop, between lines 2 and 3, so it initializes once before the loop starts.
Correct Answer: C: Move the statement in line 5 to between lines 2 and 3.
Tip: If a code question stumps you, rewrite the code by hand to spot errors more clearly. Pay attention to details like indentation.

Key Terms

• Bugs: Flaws in a program causing unexpected behavior, from simple typos to complex logic issues.
• Debuggers: Tools that help programmers locate and fix bugs.
• Error Messages: Alerts that describe a problem in the code, aiding in debugging.
• Hand Tracing: Manually tracking variable values to understand code execution.
• Logic Errors: Mistakes in a program’s reasoning that lead to incorrect outputs.
• Print Statements: Code lines that display variable values or messages during execution.
• Test Cases: Inputs and expected outputs used to verify a program’s functionality.
• Testing: The process of checking if a program meets its requirements and works correctly.
• Visualizations: Graphical tools, like charts, that help analyze code or data.