Testing and debugging programs

Learn it by playing

Answer these questions to earn energy, then fish and explore. No account needed.

For educators: ready-to-use lesson slides, revision notes for Testing and debugging programs (KS3 Computing, Computer Science) — use them in your lesson, or run the topic as an interactive class activity your learners play as a live game.

Lesson notes

What are Bugs and Debugging?

A bug is a defect or fault in a program that causes it to behave incorrectly.
Debugging is the process of finding the root cause of a bug, and then fixing it.
The term 'bug' dates back to at least 1878, used by Thomas Edison for 'little faults and difficulties'.
A famous story from the 1940s: Grace Hopper's team found a moth in a relay, calling it the 'first actual case of a bug being found'.
Debugging can involve interactive debugging, control flow analysis, log file analysis, and using debuggers.

Debugging is a routine: reproduce, gather clues, form a hypothesis, isolate the cause, fix it, then retest.

Types of Errors

Syntax errors: mistakes in the grammar of the programming language, e.g., missing semicolon or misspelled keyword. The program won't run.
Runtime errors: occur while the program is running, e.g., dividing by zero or trying to open a file that doesn't exist.
Logic errors: the program runs but produces wrong results because the algorithm or code logic is flawed.
Error messages from the compiler or interpreter help locate syntax errors; runtime errors often show a traceback.
Logic errors are hardest to find because there is no error message – you must test and trace the code.

Syntax errors stop the program running, logic errors run but give the wrong result, runtime errors crash it during execution.

Testing Strategies

Normal data: typical input that the program should handle correctly.
Boundary data: values at the limits of the valid range, e.g., 0, maximum, or minimum – these often reveal bugs.
Erroneous data: invalid or unexpected input, e.g., letters when numbers are expected – the program should handle gracefully.
Test with a range of inputs to ensure the program works in all cases.
Use test plans to list inputs, expected outputs, and actual outputs.

Normal, boundary and invalid test data check that a program handles each kind of input correctly.

Reading Error Messages

Error messages often include the line number and a description of the problem.
For syntax errors, look at the indicated line and the line before – the error may be there.
Runtime error messages (e.g., in Python) show a traceback with the sequence of function calls.
Read the error type (e.g., NameError, TypeError) – it tells you what kind of problem occurred.
Don't panic – read carefully and use the message to guide your search.

Debugging Techniques

Print statements: add temporary output to show variable values at different points.
Trace tables: manually step through the code, recording variable values in a table.
Breakpoints: set in a debugger to pause execution at a specific line, then inspect variables.
Step through code line by line using a debugger to see how values change.
Rubber duck debugging: explain your code line by line to a rubber duck (or a friend) – often you spot the mistake yourself.
Isolate the problem: narrow down the part of the code that causes the bug.

Breakpoints pause execution, variable inspection shows the current state, and stepping runs one instruction at a time.

Using Debuggers

A debugger is a tool that lets you monitor program execution, stop it, restart it, set breakpoints, and change values in memory.
Debuggers allow you to inspect variables at any point.
They help you step through code line by line.
High-level languages (like Python, Java) often have built-in debuggers or easy-to-use ones.
Debuggers are especially useful for finding logic errors.

A debugger runs to a breakpoint, lets you inspect the variables, then steps on to the next line.

Common Pitfalls

Off-by-one errors: loops that run one too many or too few times.
Uninitialized variables: using a variable before giving it a value.
Incorrect conditions: using = instead of ==, or wrong comparison operators.
Assuming input is always valid – always validate user input.
Not testing boundary values – these often cause failures.

Plan the test, observe the result, locate the issue, correct it, then run the test again.

Good Debugging Practice

Be systematic: test one thing at a time, change one thing at a time.
Keep a record of what you tried and what happened.
Don't guess – use evidence from tests and error messages.
Take breaks – a fresh look often helps.
Ask for help after trying reasonable steps yourself.
Learn from bugs – they help you understand your code better.

Slides

Step through every slide for this topic — plus flashcards and revision notes — with a free account.

Practice questions

Free preview — 8 of 59 questions. Sign up to see them all.

1.Which term is used to describe a defect or fault in a computer program?
Easy
- ABug
- BPatch
- CDebug
- DGlitch
2.Which type of error is a violation of the rules of the programming language, such as a missing semicolon or misspelled keyword?
Easy
- ASyntax error
- BRuntime error
- CLogic error
- DType error
3.A debugger is a software tool that allows a programmer to monitor the execution of a program, set breakpoints, and change values in memory.
Easy
True or false?
4.A program asks the user to enter their age. Which of the following test inputs would be a boundary value?
Medium
- A0
- B17
- C18
- D150
5.Which of the following are common types of program errors? (select all that apply)
Medium
- ASyntax errors
- BRuntime errors
- CLogic errors
- DCompilation errors
- EDesign errors
6.Match each type of error with its description.
Medium
- Syntax error
- Runtime error
- Logic error
- Violates language rules
- Occurs during execution
- Program runs but gives wrong output
7.Put these steps of debugging a program in the correct order.
Medium
- Identify the error message
- Locate the faulty line of code
- Fix the code
- Test the program again
8.A logic error will always cause the program to crash or stop running.
Easy
True or false?

Revision notes

## Testing and Debugging Programs ### Types of Errors - **Syntax errors**: Mistakes in the grammar of the programming language. The program won't run until these are fixed. - **Runtime errors**: Occur while the program is running, e.g., dividing by zero or trying to open a file that doesn't exist. These often crash the program. - **Logic errors**: The program runs but does the wrong thing because the logic is flawed. These are hardest to find. ### Testing with Different Data - **Normal data**: Typical inputs the program is designed to handle. - **Boundary data**: Values at the edges of the valid range (e.g., minimum and maximum). These often reveal errors. - **Erroneous data**: Invalid inputs (e.g., wrong type or out of range). A good program should handle these gracefully, not crash. ### Debugging Strategies - **Read error messages**: They often tell you the line number and type of error. - **Trace the program**: Go through your code line by line, checking values of variables. - **Use a debugger**: A tool that lets you pause execution, set breakpoints, and inspect variables. - **Add print statements**: Temporarily output values to see what's happening. - **Simplify**: Isolate the problem by testing small parts of the code. ### The Origin of "Bug" and "Debugging" - The term "bug" for a defect dates back to at least 1878, used by Thomas Edison. - A famous story: In the 1940s, Admiral Grace Hopper's team found a moth stuck in a relay of the Mark II computer, logging "First actual case of a bug being found." - "Debugging" was used in aeronautics before computing, e.g., in a 1944 letter by J. Robert Oppenheimer. ### Key Points - Not all bugs are critical; assess impact before fixing. - High-level languages (like Python or Java) often make debugging easier due to features like exception handling. - Static analysis tools can find potential errors without running the program, but may give false positives. ### Remember - Test with a range of data: normal, boundary, and erroneous. - Use systematic debugging: understand the error, trace the logic, and fix the root cause.

Syntax error: An error in the grammar of a programming language; the program cannot run until it is corrected.
Runtime error: An error that occurs while a program is running, often causing it to crash.
Logic error: An error where the program runs but produces incorrect results due to flawed logic.
Normal data: Typical inputs that a program is designed to handle correctly.
Boundary data: Inputs at the edges of the valid range, such as minimum or maximum values, often used to test edge cases.
Erroneous data: Invalid inputs that a program should handle gracefully without crashing.
Debugging: The process of finding and fixing bugs (errors) in a program.
Debugger: A software tool that helps monitor program execution, set breakpoints, and inspect variables.
Breakpoint: A point in a program where execution pauses, allowing the programmer to inspect the state.
Trace: To step through code line by line, observing the flow and variable values.
Static analysis: Analyzing source code without running it to find potential errors.
Bug: A defect or error in a program that causes incorrect behavior.

Flashcards

What are the three main types of programming errors?

Syntax errors, runtime errors, and logic errors.

Define a syntax error.

A syntax error is a mistake in the code's grammar or structure, such as a missing semicolon or misspelled keyword, which prevents the program from running.

Define a runtime error.

A runtime error occurs while the program is running, such as division by zero or trying to access a file that doesn't exist, causing the program to crash or halt.

Define a logic error.

A logic error is a mistake in the program's algorithm or reasoning, causing it to produce incorrect results without crashing.

Why is reading error messages important?

Error messages provide clues about the type and location of a problem, helping programmers identify and fix errors more efficiently.

What is normal data in testing?

Normal data is typical, valid input that the program is expected to handle correctly.

What is boundary data in testing?

Boundary data is input at the edges of acceptable ranges, such as the minimum or maximum values, to test how the program handles limits.

What is erroneous data in testing?

Erroneous data is invalid or unexpected input that the program should handle gracefully, such as rejecting it with an error message.

What is tracing in debugging?

Tracing involves stepping through code line by line or adding print statements to track the program's execution and variable values to find where things go wrong.

What is a debugger?

A debugger is a software tool that allows programmers to monitor program execution, set breakpoints, stop and restart the program, and inspect or change memory values.

What is a breakpoint?

A breakpoint is a marker set in a debugger that pauses program execution at a specific line so the programmer can inspect the state.

What is the origin of the term 'bug' in computing?

The term 'bug' was popularized by Grace Hopper when a moth was found in a relay of the Mark II computer, though the term was used earlier by Edison.

What is the difference between a syntax error and a logic error?

A syntax error prevents the program from running due to incorrect grammar, while a logic error allows the program to run but produces wrong results.

Why might a programmer use static code analysis tools?

Static code analysis tools scan source code for known problems without running it, helping to detect issues like using a variable before it is assigned.

What is a false positive in static code analysis?

A false positive is when the tool flags correct code as potentially erroneous, which can be misleading.

What is the purpose of testing with boundary data?

Boundary testing checks how the program handles values at the edges of input ranges, which often reveal off-by-one or overflow errors.

What is the purpose of testing with erroneous data?

Erroneous data testing ensures the program handles invalid input gracefully, such as showing an error message rather than crashing.

What is the first step in debugging?

The first step is to reproduce the problem consistently so you can observe the error and begin investigating its cause.

What does 'tracing' mean in the context of debugging?

Tracing means following the flow of execution and tracking variable values to pinpoint where the program deviates from expected behavior.

What is a runtime error example?

A runtime error example is dividing by zero, which causes the program to crash during execution.

What is a logic error example?

A logic error example is using the wrong formula to calculate area, so the program runs but gives incorrect results.

Why is it important to test with a variety of data?

Testing with normal, boundary, and erroneous data helps uncover different types of errors and ensures the program is robust.

What is the role of error messages in debugging?

Error messages provide specific information about the error type and location, guiding the programmer to the source of the problem.

What is the difference between a debugger and a static analysis tool?

A debugger runs the program and allows interactive inspection, while a static analysis tool examines the code without executing it.

Unlock all 59 questions, flashcards & more

Create a free account to see every question, the slides, flashcards and revision notes for this topic.

Past papers

Past-paper practice for this topic is coming soon.

Coming soon