Robust Programs (GCSE & IGCSE Computer Science): Revision Notes and Worksheets

GCSE and IGCSE Computer Science robust programs: misuse, validation, verification, authentication, testing, syntax and logic errors, test data, test plans.

Number line for a car park that accepts stays of 1 to 24 hours, labelling test data with the OCR names (normal, boundary, invalid, erroneous) above and the Cambridge names (normal, extreme, boundary, abnormal) below.

A program that works when you type the right thing is only half finished. A robust program copes with whatever users actually type, and has been tested to prove it. This guide covers GCSE and IGCSE robust programs: anticipating misuse, input validation, validation and verification, authentication, why and when we test, syntax and logic errors, choosing test data and writing a test plan. Each part has a worked example and a worksheet for your exam board.

Cambridge IGCSE 0478 students: you need O2, O3, O5, O6, O7 and O8, and only the points marked IGCSE only or Both boards. Parts O1 and O4 are on the OCR J277 specification only. OCR J277 students: skip O3, which is on the Cambridge 0478 syllabus only.

What does robust programs cover for OCR and Cambridge?

A robust program deals with every likely input, valid or not, and has been tested so that it works as intended. OCR J277 covers this in topic 2.3, Producing robust programs: defensive design (2.3.1) and testing (2.3.2). Cambridge IGCSE 0478 covers the same skills inside topic 7, Algorithm design and problem-solving: the program development life cycle (7.1), validation and verification (7.5), test data (7.6) and finding errors (7.8). The table below is based on the OCR J277 specification (version 3.1) and the Cambridge IGCSE 0478 syllabus for 2026-2028, as checked in November 2026. GCSE only: maintainability (sub programs, naming conventions, indentation and commenting), the fourth defensive design point in J277 2.3.1, is covered in Programming revision notes (M28).

Part

Topic

OCR J277

Cambridge 0478

O1

Anticipating misuse (GCSE only)

2.3.1

not on syllabus

O2

Input validation (both boards)

2.3.1

7.5(a)

O3

Validation and verification (IGCSE only)

not on specification

7.5(b)

O4

Authentication (GCSE only)

2.3.1

not on syllabus (passwords as a security measure are in 5.3)

O5

Why we test: iterative and final testing (both boards)

2.3.2

7.1

O6

Syntax and logic errors (both boards)

2.3.2

7.8

O7

Choosing test data (both boards)

2.3.2

7.6

O8

Writing a test plan (both boards)

2.3.2

7.6

O1: What does anticipating misuse mean in defensive design?

GCSE only. Defensive design means designing a program so that it caters for all likely input values and keeps working whatever the user does. J277 lists four defensive design considerations: anticipating misuse, authentication (O4), input validation (O2) and maintainability.

Anticipating misuse means thinking ahead about every way a user could enter the wrong thing, by accident or on purpose, and planning how the program will deal with each one.

  • Accidental misuse: the wrong data type ("three" instead of 3), a value out of range, a blank input, text that is far too long, or a menu choice that does not exist.

  • Deliberate misuse: guessing a password over and over again, or typing malicious input such as SQL injection (the attack itself is in Security revision notes, G6).

The program should deal with invalid data: reject it, tell the user what is wrong and ask again. It must never crash or store the invalid data. It should also guard risky operations: check that a number is not 0 before dividing by it, and that an array index is in range before using it.

Worked example: anticipating misuse in a running log (GCSE only)

A fitness club's program asks a member for the total distance they ran (in km) and the number of sessions, then outputs the average distance per session: totalKm / sessions. For 42 km over 6 sessions it outputs 42 ÷ 6 = 7.0 km.

  • Step 1: list the likely invalid inputs for sessions: 0 (the division would stop the program with an error), a negative number such as -2, a word such as "six", and a blank input.

  • Step 2: decide how to deal with each: reject it, output a message such as "Enter a whole number of 1 or more", and ask again until the input is valid.

  • Step 3: guard the division in OCR Exam Reference Language, so the program only divides once sessions is 1 or more:

totalKm = float(input("Total distance in km"))
sessions = int(input("Number of sessions"))
while sessions < 1
    print("Enter a whole number of 1 or more")
    sessions = int(input("Number of sessions"))
endwhile
average = totalKm / sessions
totalKm = float(input("Total distance in km"))
sessions = int(input("Number of sessions"))
while sessions < 1
    print("Enter a whole number of 1 or more")
    sessions = int(input("Number of sessions"))
endwhile
average = totalKm / sessions
totalKm = float(input("Total distance in km"))
sessions = int(input("Number of sessions"))
while sessions < 1
    print("Enter a whole number of 1 or more")
    sessions = int(input("Number of sessions"))
endwhile
average = totalKm / sessions

Practise O1: OCR questions · OCR mark scheme

O2: What is input validation and what are the validation checks?

Both boards. Validation is an automatic check, carried out by the program, that input data is sensible and follows set rules before it is accepted. Validation cannot check that the data is correct: 31 passes a range check for a day of the month even if the real date was the 13th.

Check

What it checks

Example rule

Range check

The value is between set limits

A mark from 0 to 100 inclusive

Type check

The data is the expected data type

Number of nights must be a whole number, not text

Presence check

Something has been entered: the field is not blank

A surname must be entered

Length check

The number of characters is within limits

A password of at least 8 characters

Format check

The data matches a set pattern

A date as DD/MM/YYYY

A validation loop keeps asking until the input is valid: input, check, and if the input is invalid, output an error message and input again. An IF on its own only checks once, so a second invalid input would get through.

Flowchart of a validation loop: input the data, check it against the rules; if it is invalid, output an error message and input it again; if it is valid, accept it and carry on.

GCSE only: J277 places validation under defensive design and does not give a fixed list of check names. You need practical experience of designing input validation, so be ready to write a validation loop in OCR Exam Reference Language or a high-level language.

IGCSE only: Cambridge 0478 names six validation checks: the five above and the check digit. A check digit is an extra digit calculated from the other digits of a code and added to the end, for example in an ISBN or a barcode. When the code is entered, the digit is calculated again; if it does not match, the code was entered wrongly, for example with two digits swapped. (How check digits are calculated is in Data transmission revision notes, D5.)

Worked example: choose the checks, then write the loop (both boards)

A campsite's booking program asks for three inputs.

  • Step 1: number of nights, a whole number from 1 to 21: a type check and a range check.

  • Step 2: pitch code, one capital letter then two digits, such as B07: a length check (exactly 3 characters) and a format check (B7 fails both; 7B0 has the right length but fails the format check).

  • Step 3: lead booker's surname: a presence check (not blank) and a length check (no more than 30 characters).

  • Step 4: write the validation loop for the number of nights. With the inputs 0, 25 and then 7, both versions output the error message twice, then accept 7.

GCSE only (OCR Exam Reference Language):

nights = int(input("Number of nights (1 to 21)"))
while nights < 1 OR nights > 21
    print("Enter a whole number from 1 to 21")
    nights = int(input("Number of nights (1 to 21)"))
endwhile
nights = int(input("Number of nights (1 to 21)"))
while nights < 1 OR nights > 21
    print("Enter a whole number from 1 to 21")
    nights = int(input("Number of nights (1 to 21)"))
endwhile
nights = int(input("Number of nights (1 to 21)"))
while nights < 1 OR nights > 21
    print("Enter a whole number from 1 to 21")
    nights = int(input("Number of nights (1 to 21)"))
endwhile

IGCSE only (Cambridge pseudocode):

REPEAT
    OUTPUT "Number of nights (1 to 21)"
    INPUT Nights
    IF Nights < 1 OR Nights > 21
      THEN
        OUTPUT "Enter a whole number from 1 to 21"
    ENDIF
UNTIL Nights >= 1 AND Nights <= 21
REPEAT
    OUTPUT "Number of nights (1 to 21)"
    INPUT Nights
    IF Nights < 1 OR Nights > 21
      THEN
        OUTPUT "Enter a whole number from 1 to 21"
    ENDIF
UNTIL Nights >= 1 AND Nights <= 21
REPEAT
    OUTPUT "Number of nights (1 to 21)"
    INPUT Nights
    IF Nights < 1 OR Nights > 21
      THEN
        OUTPUT "Enter a whole number from 1 to 21"
    ENDIF
UNTIL Nights >= 1 AND Nights <= 21

Practise O2: OCR questions · OCR mark scheme · Cambridge questions · Cambridge mark scheme

O3: What is the difference between validation and verification?

IGCSE only. Verification checks that data has been entered or copied accurately: that it matches the original it came from. Validation checks that data is sensible and follows the rules. Verification is needed because valid data can still be wrong: a clerk who types 36 instead of 63 still passes a range check of 1 to 100.

  • Visual check: the data entered is shown on the screen and the user compares it by eye with the original, then confirms it (Y) or enters it again (N).

  • Double entry check: the data is entered twice and the program compares the two entries. If they are different, the user is asked to enter the data again.

Verification cannot tell if the original itself is wrong: it only checks that the entry matches it. The Cambridge 0478 syllabus asks for the purpose of each check and for algorithms for both.

Worked example: a double entry check in pseudocode (IGCSE only)

A library enters each new member's phone number twice.

  • Step 1: input the number twice and compare the two entries.

  • Step 2: if they are different, output a message and repeat; stop when they are the same.

  • Step 3: trace it. First pair: 01632 960418 and 01632 960481 (the last two digits are swapped), so the entries do not match and the loop repeats. Second pair: 01632 960418 twice, so the loop ends and "Phone number saved" is output.

REPEAT
    OUTPUT "Enter the phone number"
    INPUT Phone1
    OUTPUT "Enter the phone number again"
    INPUT Phone2
    IF Phone1 <> Phone2
      THEN
        OUTPUT "The entries do not match, please enter them again"
    ENDIF
UNTIL Phone1 = Phone2
OUTPUT "Phone number saved"
REPEAT
    OUTPUT "Enter the phone number"
    INPUT Phone1
    OUTPUT "Enter the phone number again"
    INPUT Phone2
    IF Phone1 <> Phone2
      THEN
        OUTPUT "The entries do not match, please enter them again"
    ENDIF
UNTIL Phone1 = Phone2
OUTPUT "Phone number saved"
REPEAT
    OUTPUT "Enter the phone number"
    INPUT Phone1
    OUTPUT "Enter the phone number again"
    INPUT Phone2
    IF Phone1 <> Phone2
      THEN
        OUTPUT "The entries do not match, please enter them again"
    ENDIF
UNTIL Phone1 = Phone2
OUTPUT "Phone number saved"

A visual check algorithm has the same shape: input the data, output it with a question such as "Is this correct? (Y/N)", input the reply, and repeat UNTIL Reply = "Y".

Practise O3: Cambridge questions · Cambridge mark scheme

O4: How does a program authenticate a user?

GCSE only. Authentication confirms the identity of a user before they are allowed to use a program or its data. J277 asks for practical experience of simple authentication, such as a username and password.

  • The program inputs the username and password and compares them with the stored values.

  • Access is given only if both match (the condition uses AND, not OR).

  • Limit the number of attempts, for example lock the account after 3 failures, to stop someone guessing the password over and over again (a brute-force attack).

  • The error message should not say which item was wrong, so it gives an attacker no clues. Stronger programs also enforce strong passwords or add a second factor.

Worked example: trace a login with three attempts (GCSE only)

A charity's volunteer rota program stores the username rota_admin and the password Lantern!62.

attempts = 0
loggedIn = false
while attempts < 3 AND loggedIn == false
    user = input("Username")
    pwd = input("Password")
    if user == storedUser AND pwd == storedPwd then
        loggedIn = true
    else
        print("Username or password incorrect")
    endif
    attempts = attempts + 1
endwhile
if loggedIn == true then
    print("Access granted")
else
    print("Account locked")
endif
attempts = 0
loggedIn = false
while attempts < 3 AND loggedIn == false
    user = input("Username")
    pwd = input("Password")
    if user == storedUser AND pwd == storedPwd then
        loggedIn = true
    else
        print("Username or password incorrect")
    endif
    attempts = attempts + 1
endwhile
if loggedIn == true then
    print("Access granted")
else
    print("Account locked")
endif
attempts = 0
loggedIn = false
while attempts < 3 AND loggedIn == false
    user = input("Username")
    pwd = input("Password")
    if user == storedUser AND pwd == storedPwd then
        loggedIn = true
    else
        print("Username or password incorrect")
    endif
    attempts = attempts + 1
endwhile
if loggedIn == true then
    print("Access granted")
else
    print("Account locked")
endif
  • Step 1: rota_admin and lantern!62: the password's capital L is missing, so "Username or password incorrect"; attempts becomes 1.

  • Step 2: rota-admin and Lantern!62: the username has a hyphen, not an underscore, so the same message; attempts becomes 2.

  • Step 3: rota_admin and Lantern!62: both match, loggedIn becomes true, attempts becomes 3, the loop stops and the output is Access granted. If the third try had also been wrong, the output would be Account locked.

Practise O4: OCR questions · OCR mark scheme

O5: Why do we test programs, and what is iterative and final testing?

Both boards. The purpose of testing is to find and remove errors, and to show that the program works as intended and meets the requirements. Testing also checks that the program copes with invalid or unexpected input without crashing. Each test uses chosen test data (O7) and compares the actual result with the expected result (O8).

Iterative testing is carried out during development: each module is tested as it is written, errors are fixed, and the module is tested again, over and over, before moving on. It finds errors early, in small parts of the code, where they are easier to find.

GCSE only: J277 contrasts iterative testing with final (terminal) testing: testing the whole program at the end of production, to check that all the modules work together and that the program meets all the requirements.

IGCSE only: Cambridge 0478 places testing in the program development life cycle (analysis, design, coding, testing). The coding stage is writing program code and iterative testing; the testing stage is testing program code with the use of test data. "Final/terminal testing" is not 0478 wording: call it the testing stage.

Worked example: testing a car park app (both boards)

A programmer builds a car park app in three modules: one checks the car registration, one works out the charge and one shows the ticket.

  • Step 1: the charge module is tested on its own as soon as it is written. A stay of 3 hours gives the wrong charge, so the error is fixed and the module is tested again. That is iterative testing (IGCSE: part of the coding stage).

  • Step 2: the registration and ticket modules are written and tested in the same way, one at a time.

  • Step 3: the whole app is run with a full set of test data, to check that the modules work together and that it does everything the car park asked for. GCSE: this is final/terminal testing. IGCSE: this is the testing stage.

  • Step 4: every module passing on its own does not prove the whole app works: the charge module might pass the wrong value to the ticket module. That is why the final testing is still needed.

Practise O5: OCR questions · OCR mark scheme · Cambridge questions · Cambridge mark scheme

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

Both boards. You must be able to find errors in given code or algorithms and suggest a correction. Typical errors: a misspelt keyword, a missing bracket or ENDIF, the wrong comparison (> instead of >=), AND and OR swapped, a loop that runs once too many or too few times, a total reset inside a loop, or the wrong variable used. Trace tables and test data with known expected results show where the output goes wrong (trace tables are in Algorithm design revision notes).

GCSE only: J277 names two types of error, and you need the definitions.

  • Syntax error: an error that breaks the grammatical rules of the programming language and stops it from being run or translated. Examples: print("Hello" (missing bracket), pirnt, or a missing endif. The translator reports it.

  • Logic error: an error that produces unexpected output. The program runs, but gives the wrong result, and no error message is shown, so it is found by testing. In your own exam code, OCR says it avoids penalising minor syntax errors, but your logic must be right.

IGCSE only: 0478 7.8 does not name error types: you identify the error in a given algorithm and suggest a way of correcting it, in pseudocode. The syllabus says programming language syntax is not examined; the logic is more important than the syntax. (How a compiler and an interpreter report errors is in 0478 4.2, Paper 1.)

Worked example: find the error in a lap-time average (both boards)

A running coach enters 4 lap times, in seconds, and wants the mean. For 50, 52, 48 and 54 the total is 204, so the expected output is 204 ÷ 4 = 51.

GCSE only (OCR Exam Reference Language):

01 for lap = 1 to 4
02     total = 0
03     time = float(input("Lap time"))
04     total = total + time
05 next lap
06 print(total / 4)
01 for lap = 1 to 4
02     total = 0
03     time = float(input("Lap time"))
04     total = total + time
05 next lap
06 print(total / 4)
01 for lap = 1 to 4
02     total = 0
03     time = float(input("Lap time"))
04     total = total + time
05 next lap
06 print(total / 4)

IGCSE only (Cambridge pseudocode):

01 FOR Lap ← 1 TO 4
02     Total ← 0
03     INPUT Time
04     Total ← Total + Time
05 NEXT Lap
06 OUTPUT Total / 4
01 FOR Lap ← 1 TO 4
02     Total ← 0
03     INPUT Time
04     Total ← Total + Time
05 NEXT Lap
06 OUTPUT Total / 4
01 FOR Lap ← 1 TO 4
02     Total ← 0
03     INPUT Time
04     Total ← Total + Time
05 NEXT Lap
06 OUTPUT Total / 4
  • Step 1: run the test. The actual output is 13.5, not 51, so there is an error.

  • Step 2: trace it. Line 02 sets the total back to 0 on every pass, so after the last lap the total is only 54, and 54 ÷ 4 = 13.5.

  • Step 3: correct it: move the line total = 0 (Total ← 0) to before the loop. Now the total is 204 and the output is 51.

  • Step 4 (GCSE only): name it. The program ran but gave the wrong output, so it is a logic error. If line 06 had been print(total / 4 with a missing bracket, the program would not run at all: a syntax error.

Practise O6: OCR questions · OCR mark scheme · Cambridge questions · Cambridge mark scheme

O7: What are normal, boundary, invalid, erroneous, abnormal and extreme test data?

Both boards. Test data is the values chosen to check that a program accepts what it should and rejects what it should. Normal test data is data that should be accepted by the program without causing errors. The two boards use different names for the other types, and "boundary" means different things on each board. Learn only your own board's set.

GCSE only (OCR J277): normal, boundary, invalid and erroneous.

  • Boundary: data of the correct type on the very edge of being valid: the largest and smallest acceptable values.

  • Invalid: data of the correct data type that should be rejected, such as a number outside the range.

  • Erroneous: data of the incorrect data type that should be rejected, such as text when a number is expected.

IGCSE only (Cambridge 0478): normal, abnormal, extreme and boundary.

  • Abnormal: data that should be rejected: out of range, or the wrong type.

  • Extreme: the largest or smallest acceptable value. It is one value, and it is accepted.

  • Boundary: the largest or smallest acceptable value and the corresponding smallest or largest rejected value. It is a pair: one accepted, one rejected.

Number line for a car park that accepts stays of 1 to 24 hours, labelling test data with the OCR names (normal, boundary, invalid, erroneous) above and the Cambridge names (normal, extreme, boundary, abnormal) below.

Worked example: test data for a 1 to 24 hour stay (both boards)

A car park accepts a stay of a whole number of hours from 1 to 24 inclusive. Always give actual values, not descriptions.

Test data

OCR J277 type (GCSE)

Cambridge 0478 type (IGCSE)

Expected outcome

10

Normal

Normal

Accepted

1

Boundary

Extreme (and boundary, paired with 0)

Accepted

24

Boundary

Extreme (and boundary, paired with 25)

Accepted

0

Invalid

Abnormal (and boundary, paired with 1)

Rejected

25

Invalid

Abnormal (and boundary, paired with 24)

Rejected

six

Erroneous

Abnormal

Rejected

  • Step 1: pick a value well inside the range: 10 is normal on both boards.

  • Step 2: test both edges. GCSE: 1 and 24 are boundary data. IGCSE: 1 and 24 are extreme data; the boundary pairs are 0 and 1, and 24 and 25.

  • Step 3: test values that must be rejected. GCSE: 0 and 25 are invalid (right type), and "six" is erroneous (wrong type). IGCSE: all three are abnormal.

Practise O7: OCR questions · OCR mark scheme · Cambridge questions · Cambridge mark scheme

O8: How do you write a test plan?

Both boards. A test plan is a table that plans each test before it is run. For each test it gives the test number, what is being tested, the test data, the type of test data and the expected result. When the tests are run, the actual result and pass or fail are recorded. A failed test leads to a fix and a re-test.

  • Make every expected result specific: "Accepted, cost £5" or "Rejected, error message shown", never just "works".

  • Cover every rule with each type of test data, including both edges of every range.

  • Test every route through the program: each branch of an IF and each menu option.

GCSE only: creating or completing a test plan is a named J277 skill. Label rows with the OCR types (normal, boundary, invalid, erroneous). Refining algorithms means using failed tests to correct or improve the code, then testing again.

IGCSE only: 0478 7.6 asks you to suggest and apply suitable test data: give the value, its type (normal, abnormal, extreme, boundary) and the expected outcome, often in the same kind of table. Applying test data is the testing stage of the program development life cycle.

Worked example: a test plan for a delivery charge (both boards)

A garden centre delivers to customers from 1 to 30 miles away (whole numbers only). A delivery of up to 10 miles costs £5; more than 10 miles costs £10. Any other distance is rejected with an error message.

Test

Test data (miles)

GCSE type

IGCSE type

Expected result

1

6

Normal

Normal

Accepted, cost £5

2

20

Normal

Normal

Accepted, cost £10

3

10

Normal

Normal

Accepted, cost £5 (top of the £5 band)

4

1

Boundary

Extreme

Accepted, cost £5

5

30

Boundary

Extreme

Accepted, cost £10

6

0

Invalid

Abnormal (boundary pair with 1)

Rejected, error message

7

31

Invalid

Abnormal (boundary pair with 30)

Rejected, error message

8

ten

Erroneous

Abnormal

Rejected, error message

  • Step 1: test 3 checks the edge of the price rule, not just the edge of the valid range. Both routes through the IF need testing.

  • Step 2: the plan is run. Every test passes except test 3: the actual result is £10. Fail.

  • Step 3: the code says if miles < 10 then (Cambridge: IF Miles < 10). The rule says "up to 10 miles", so it should be <= 10. The code is corrected and all the tests are run again; test 3 now gives £5, a pass.

Practise O8: OCR questions · OCR mark scheme · Cambridge questions · Cambridge mark scheme

Common exam mistakes in robust programs

  • Saying validation checks that data is correct. It only checks that data is sensible and follows the rules.

  • Using an IF to validate input, so it is only checked once. Use a loop that repeats until the input is valid.

  • (IGCSE) Mixing up validation and verification: a double entry check and a visual check are verification, not validation.

  • (GCSE) Mixing up invalid (correct data type, rejected) and erroneous (incorrect data type, rejected) test data.

  • (IGCSE) Giving one value as boundary data. Boundary is a pair: the largest or smallest accepted value and the rejected value next to it. One accepted edge value is extreme.

  • Describing test data ("a number in range") instead of giving an actual value such as 10.

  • (GCSE) Calling an error that gives the wrong answer a syntax error. If the program runs but the output is wrong, it is a logic error.

  • Writing an expected result of "it works". Say exactly what should happen: accepted, output £5 or rejected, error message.

Quick recap

  • O1: (GCSE only) anticipating misuse: plan for every likely invalid input, accidental or deliberate; reject it, explain, ask again; guard divisions and array indexes.

  • O2: validation is an automatic check that input is sensible: range, type, presence, length, format; use a loop; check digit IGCSE only.

  • O3: (IGCSE only) verification checks data matches the original: visual check and double entry check.

  • O4: (GCSE only) authentication confirms a user's identity: compare username AND password with stored values; limit attempts.

  • O5: testing finds errors and shows the program meets its requirements; iterative testing during development; final/terminal testing GCSE only; coding and testing stages of the PDLC IGCSE only.

  • O6: find errors in code and correct them; syntax error (breaks the rules, will not run) and logic error (runs, wrong output) named GCSE only.

  • O7: normal data on both boards; GCSE: boundary, invalid, erroneous; IGCSE: abnormal, extreme, boundary (a pair).

  • O8: a test plan gives test data, type and a specific expected result; record actual results, fix failures and re-test.

Download the whole module

Frequently asked questions

Which parts of robust programs are on the Cambridge IGCSE 0478 syllabus?

O2, O3, O5, O6, O7 and O8: validation, verification, testing in the program development life cycle, finding and correcting errors, and test data. Anticipating misuse (O1) and authentication (O4) are on OCR J277 only, and verification (O3) is on Cambridge 0478 only.

What is the difference between validation and verification?

Validation is an automatic check that input data is sensible and follows set rules, such as a range check. Verification checks that data has been entered or copied accurately, so that it matches the original, using a visual check or a double entry check.

What is the difference between invalid and erroneous test data?

Both should be rejected by the program. Invalid test data is the correct data type, such as 25 when only 1 to 24 is allowed; erroneous test data is the incorrect data type, such as the word six when a number is expected. These are the OCR J277 terms.

What is the difference between extreme and boundary test data?

In Cambridge IGCSE 0478, extreme data is the largest or smallest acceptable value, such as 24 for a range of 1 to 24. Boundary data is that value together with the rejected value next to it, such as 24 and 25.

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

A syntax error breaks the grammatical rules of the programming language, so the program cannot be run or translated. A logic error lets the program run but produces unexpected or incorrect output, so it is found by testing.

What is the difference between iterative and final testing?

Iterative testing happens during development: each module is tested as it is written, fixed and tested again. Final, or terminal, testing happens at the end of production and tests the whole program against its requirements.

Previous module: Databases and SQL revision notes.

More help: browse the GCSE Computer Science revision hub.