Why is "Saying that a WHILE loop and a REPEAT…UNTIL loop 'do the same thing', or being unable to state which one is guaranteed to run at least once." a common mistake in Programming concepts?

Why it happens: In most everyday programs the two produce identical output, so the difference never shows up in classroom work — and many centres teach Python, which has no native condition-at-the-end construct at all. How to avoid it: Anchor it to one sentence: **WHILE tests first, so it may run ZERO times; REPEAT tests last, so it ALWAYS runs at least ONCE.** Then remember why validation uses REPEAT — you cannot test a value before you have obtained one. AQA requires theoretical understanding of both regardless of your taught language. Source: AQA 8525 specification 3.2.2 additional information: 'A theoretical understanding of condition(s) at either end of an iterative structure is required, regardless of whether they are supported by the language(s) being used.'

Why is "Converting a WHILE loop to a REPEAT loop (or vice versa) without inverting the condition." a common mistake in Programming concepts?

Why it happens: The two structures look symmetrical, so students move the condition to the other end and copy it across unchanged, not noticing that WHILE means 'keep going while true' and UNTIL means 'keep going until true'. How to avoid it: Say the loop out loud: `WHILE password ≠ 'letmein'` means *keep looping while it is wrong*; `UNTIL password = 'letmein'` means *keep looping until it is right*. Those are **opposite** conditions. Every conversion requires flipping the operator — `≠` becomes `=`, `<` becomes `≥`, `AND` becomes `OR`. Source: Loop-conversion questions are a recurring Paper 1 shape and mark schemes award a specific mark for the inverted condition.

Why is "Adding the two loop counts instead of multiplying them when asked how many times a nested statement executes." a common mistake in Programming concepts?

Why it happens: Students see two loops and instinctively total the iterations, without picturing that the inner loop restarts from the beginning on every single pass of the outer one. How to avoid it: Fix the rule: **the inner loop runs completely for EVERY iteration of the outer loop, so multiply.** `FOR row ← 1 TO 4` containing `FOR col ← 1 TO 6` gives 4 × 6 = **24**, not 10. Sanity-check by writing out the first few pairs: (1,1) (1,2) … (1,6) (2,1) … Source: This multiplication is also the mechanism behind bubble sort's poor efficiency in 3.1.2, where the comparison count grows with roughly n × n.

Why is "Writing a WHILE loop without changing the variable the condition depends on, producing an infinite loop." a common mistake in Programming concepts?

Why it happens: A FOR loop increments its counter automatically, so students who normally use FOR forget that a WHILE loop makes the increment their responsibility. How to avoid it: Every time you write a `WHILE`, immediately ask: **what inside this loop will eventually make the condition false?** If nothing changes the tested variable, the loop can never end. Then trace two iterations by hand — an infinite loop becomes obvious within seconds. Source: Missing-increment infinite loops are a standard error-identification question on Paper 1.

Why is "Ordering ELSE IF conditions from least restrictive to most restrictive, so later branches can never be reached." a common mistake in Programming concepts?

Why it happens: It feels natural to work upwards from the lowest grade boundary, and the code looks perfectly reasonable — the bug only appears when a high value is tested, and it produces no error message. How to avoid it: Order conditions from **most restrictive to least restrictive**: check `score ≥ 70` before `score ≥ 55` before `score ≥ 40`. Once a condition is true the remaining branches are skipped, so a low threshold placed first captures everything above it too. Always test your ordering with the **highest** possible value. Source: This produces a logic error rather than a syntax error — the program runs and silently gives wrong results, which links directly to 3.2.11.

Why is "Using `=` for assignment in AQA pseudo-code, or confusing assignment with comparison inside a condition." a common mistake in Programming concepts?

Why it happens: Python and VB.NET both use `=` for assignment, and mathematics uses `=` for equality — so the single symbol carries two different meanings across the contexts students move between daily. How to avoid it: In AQA pseudo-code, **`←` assigns and `=` compares**. Read `←` as 'becomes' or 'is set to': `total ← total + 5` is 'total becomes total plus 5', which is an instruction, not a claim about equality. In a condition such as `IF answer = 4 THEN` you are asking a question, not storing anything. Source: The AQA standard pseudo-code reference document uses ← exclusively for assignment; using = there makes an algorithm ambiguous.

AQA GCSE Computer Science (8525)

Programming concepts

Q: Why is "Adding the two loop counts instead of multiplying them when asked how many times a nested statement executes." a common mistake in Programming concepts?

Why it happens: Students see two loops and instinctively total the iterations, without picturing that the inner loop restarts from the beginning on every single pass of the outer one. How to avoid it: Fix the rule: **the inner loop runs completely for EVERY iteration of the outer loop, so multiply.** `FOR row ← 1 TO 4` containing `FOR col ← 1 TO 6` gives 4 × 6 = **24**, not 10. Sanity-check by writing out the first few pairs: (1,1) (1,2) … (1,6) (2,1) … Source: This multiplication is also the mechanism behind bubble sort's poor efficiency in 3.1.2, where the comparison count grows with roughly n × n.

Q: Why is "Writing a WHILE loop without changing the variable the condition depends on, producing an infinite loop." a common mistake in Programming concepts?

Why it happens: A FOR loop increments its counter automatically, so students who normally use FOR forget that a WHILE loop makes the increment their responsibility. How to avoid it: Every time you write a `WHILE`, immediately ask: **what inside this loop will eventually make the condition false?** If nothing changes the tested variable, the loop can never end. Then trace two iterations by hand — an infinite loop becomes obvious within seconds. Source: Missing-increment infinite loops are a standard error-identification question on Paper 1.

Q: Why is "Ordering ELSE IF conditions from least restrictive to most restrictive, so later branches can never be reached." a common mistake in Programming concepts?

Why it happens: It feels natural to work upwards from the lowest grade boundary, and the code looks perfectly reasonable — the bug only appears when a high value is tested, and it produces no error message. How to avoid it: Order conditions from **most restrictive to least restrictive**: check `score ≥ 70` before `score ≥ 55` before `score ≥ 40`. Once a condition is true the remaining branches are skipped, so a low threshold placed first captures everything above it too. Always test your ordering with the **highest** possible value. Source: This produces a logic error rather than a syntax error — the program runs and silently gives wrong results, which links directly to 3.2.11.

Q: Why is "Using `=` for assignment in AQA pseudo-code, or confusing assignment with comparison inside a condition." a common mistake in Programming concepts?

Why it happens: Python and VB.NET both use `=` for assignment, and mathematics uses `=` for equality — so the single symbol carries two different meanings across the contexts students move between daily. How to avoid it: In AQA pseudo-code, **`←` assigns and `=` compares**. Read `←` as 'becomes' or 'is set to': `total ← total + 5` is 'total becomes total plus 5', which is an instruction, not a claim about equality. In a condition such as `IF answer = 4 THEN` you are asking a question, not storing anything. Source: The AQA standard pseudo-code reference document uses ← exclusively for assignment; using = there makes an algorithm ambiguous.

0% Complete

Detailed Study Notes

Detailed notes on Programming for AQA GCSE Computer Science, covering key concepts, explanations, examples, and exam-focused revision points.

Programming Concepts — AQA GCSE Computer Science 8525 (3.2.2)

This is the single biggest subtopic in the specification and the backbone of Paper 1. You must be able to use, understand and combine variable declaration, constant declaration, assignment, iteration, selection and subroutines — and critically, you need a theoretical understanding of every iteration form, including condition-at-the-end (REPEAT…UNTIL, DO…WHILE), even if your taught language doesn't support it, because AQA pseudo-code on the paper will use it.

At a glance

The three combining principles are sequence, selection and iteration — basic to all high-level imperative languages.
Variable = a named store whose value can change. Constant = a named store whose value cannot change while the program runs.
Assignment uses ← in AQA pseudo-code: total ← total + 1 means calculate the right, store it in the left.
Definite (count-controlled) iteration = FOR…ENDFOR — repeats a known number of times.
Indefinite (condition-controlled) iteration = repeats until a condition is met. The number of repeats is not known in advance.
Condition at the START (WHILE…ENDWHILE) — the body may run ZERO times.
Condition at the END (REPEAT…UNTIL / DO…WHILE) — the body always runs at least ONCE.
You need a theoretical understanding of both end positions regardless of which your language supports.
Nested = one structure inside another — nested selection (IF inside IF) and nested iteration (loop inside loop).
Meaningful identifier names (variables, constants, subroutines) are an explicit spec requirement, not a style preference.

What you’ll learn

Mapped to the AQA GCSE 8525 syllabus (2027-2029).

Use, understand and know how the following statement types can be combined in programs: variable declaration, constant declaration, assignment, iteration, selection, subroutine (procedure/function).
Know why named constants and variables are used.
Use definite (count controlled) and indefinite (condition controlled) iteration, including indefinite iteration with the condition(s) at the start or the end of the iterative structure.
Use nested selection and nested iteration structures.
Use meaningful identifier names and know why it is important to use them.

The three combining principles

Sequence, selection and iteration. Every program ever written is built from these three.

The specification states that "the three combining principles (sequence, iteration/repetition and selection/choice) are basic to all high-level imperative programming languages."

Principle	What it means	AQA pseudo-code
Sequence	Statements are carried out one after another, in the order written	one line after another
Selection	A condition decides which statements run	`IF…THEN…ELSE…ENDIF`
Iteration	Statements are repeated	`FOR…ENDFOR`, `WHILE…ENDWHILE`, `REPEAT…UNTIL`

Every program you will ever write is these three combined. Subroutines (3.2.10) then let you package them into reusable named blocks.

AQA tip. A question may show you an algorithm and ask you to identify which construct is used at a given line, or to name the construct that lets a program "repeat until the user enters a valid value" (indefinite iteration) or "do different things depending on a value" (selection). Learn the three names precisely.

Sequence = statements run one after another in order.
Selection = a condition decides which statements run (IF…THEN…ELSE).
Iteration = statements are repeated (FOR / WHILE / REPEAT).
These three combine to build every imperative program.

See the full worked example for programming concepts →

Variables, constants and assignment

A variable can change; a constant cannot. Know WHY named constants are used.

Variable declaration

A variable is a named location in memory whose value can change while the program is running.

score ← 0          # declared and given a starting value
score ← score + 10 # the value changes

Constant declaration

A constant is a named location in memory whose value is fixed when the program is written and cannot change while the program runs.

CONSTANT VAT_RATE ← 0.20
CONSTANT MAX_PLAYERS ← 4
CONSTANT PI ← 3.14159

Why use named constants? (an explicit spec requirement)

The specification says "Students should know why named constants and variables are used." Three reasons, all creditworthy:

Reason	Explanation
Easy to update	If the VAT rate changes, you edit one line instead of hunting for every `0.20` scattered through the program
Prevents accidental change	The value cannot be altered by mistake while the program runs, so it stays consistent everywhere
Makes code readable	`price * VAT_RATE` explains itself; `price * 0.20` makes the reader guess what `0.20` means

The "magic number" problem. A bare number appearing in code with no explanation is called a magic number. Compare:

# Poor — what is 0.20? What is 4? A reader cannot tell.
total ← price * 0.20
IF players > 4 THEN

# Good — self-documenting, and each value is defined in one place
CONSTANT VAT_RATE   ← 0.20
CONSTANT MAX_PLAYERS ← 4
total ← price * VAT_RATE
IF players > MAX_PLAYERS THEN

Assignment

Assignment stores a value in a variable. In AQA pseudo-code it uses a left arrow ←, not an equals sign.

Read it right-to-left: work out the right-hand side, then store the result in the left-hand side.

total ← total + 5

This is not a mathematical equation (it would be nonsense as one). It means: take the current value of total, add 5, and store the result back into total. If total was 12, it becomes 17.

AQA tip. The arrow direction matters. a ← b copies b's value into a; b ← a does the opposite. Getting these the wrong way round is a very common error in swap questions (see 3.1.4).

Variable = named store whose value CAN change; constant = fixed, cannot change while running.
Why named constants: easy to update in one place, cannot be changed accidentally, self-documenting.
Assignment ← means: evaluate the right, store into the left.
total ← total + 5 is an instruction, not an equation.

See the full worked example for programming concepts →

Selection, including nested selection

IF…THEN…ELSE chooses a path. Nested selection puts one IF inside another.

Basic selection

IF score ≥ 40 THEN
    OUTPUT 'Pass'
ELSE
    OUTPUT 'Fail'
ENDIF

Multi-way selection with ELSE IF

Test conditions in order, most specific first:

IF score ≥ 70 THEN
    grade ← 'Distinction'
ELSE IF score ≥ 55 THEN
    grade ← 'Merit'
ELSE IF score ≥ 40 THEN
    grade ← 'Pass'
ELSE
    grade ← 'Fail'
ENDIF

Why order matters. Once a condition is true, the rest are skipped. If you tested score ≥ 40 first, a score of 80 would be labelled 'Pass' and the Distinction branch would never be reached. Always go from the most restrictive condition to the least.

Nested selection — an IF inside an IF

The specification gives this exact example:

IF GameWon THEN
    … Instructions here …
    IF Score > HighScore THEN
        … Instructions here …
    ENDIF
    … Instructions here …
ENDIF

The inner IF is only ever reached if the outer condition was true. Here, the high score is only checked when the game has actually been won — which is exactly the logic you want.

Nested selection vs a compound condition. These two do the same thing:

# Nested
IF loggedIn THEN
    IF isAdmin THEN
        OUTPUT 'Admin panel'
    ENDIF
ENDIF

# Compound condition (3.2.5)
IF loggedIn AND isAdmin THEN
    OUTPUT 'Admin panel'
ENDIF

Use nesting when you need to do something different at each level (e.g. a message for "logged in but not admin"); use a compound condition when you only care about the combined case. The compound version is usually cleaner.

AQA tip. Every IF needs a matching ENDIF, and every level of nesting must be indented. The specification requires that "all logic flow is clearly identifiable to examiners" — an unindented nested IF is genuinely hard to mark and puts marks at risk.

IF…THEN…ELSE…ENDIF chooses which statements run.
With ELSE IF, order conditions from most restrictive to least — once one is true the rest are skipped.
Nested selection = an IF inside an IF; the inner one is only reached if the outer condition is true.
A compound condition (AND/OR) is usually cleaner than nesting when you only want the combined case.
Indent every level — the spec requires logic flow to be clearly identifiable.

See the full worked example for programming concepts →

Iteration: definite vs indefinite, and where the condition sits

The highest-value part of this subtopic. WHILE may run zero times; REPEAT always runs at least once.

Definite (count-controlled) iteration

Repeats a known number of times. Use when you know in advance how many repetitions are needed.

FOR i ← 1 TO 5
    OUTPUT i
ENDFOR

Indefinite (condition-controlled) iteration

Repeats until a condition is met. The number of repetitions is not known in advance — it depends on what happens while the program runs.

The specification requires a theoretical understanding of conditions at either end of the structure, "regardless of whether they are supported by the language(s) being used."

Condition at the START — WHILE…ENDWHILE

WHILE NotSolved
    … Instructions here …
ENDWHILE

Condition at the END — REPEAT…UNTIL or DO…WHILE

REPEAT
    … Instructions here …
UNTIL Solved

DO
    … Instructions here …
WHILE NotSolved

The difference that earns the marks

This single distinction — zero times versus at least once — is what "condition at the start or the end" questions are testing.

	`WHILE…ENDWHILE`	`REPEAT…UNTIL`
Condition tested	Before the body	After the body
Minimum runs	0	1
Loop continues while	Condition is True	Condition is False
Loop stops when	Condition is False	Condition is True
Best for	When it may be wrong to run even once	When the body must run at least once (e.g. asking for input)

Notice the logic is inverted. WHILE age < 0 keeps looping while the condition is true; UNTIL age ≥ 0 keeps looping until the condition becomes true. The conditions are opposites of each other. This is a classic exam question: "rewrite this WHILE loop as a REPEAT loop" requires you to invert the condition.

Why input validation naturally uses REPEAT

REPEAT
    OUTPUT 'Enter a number between 1 and 10'
    num ← STRING_TO_INT(USERINPUT)
UNTIL num ≥ 1 AND num ≤ 10

You must ask at least once — you cannot test a value you have not yet obtained. That is exactly what condition-at-the-end gives you.

AQA tip — the crucial exam rule. Python has no native DO…WHILE construct, and many centres teach Python. That does not exempt you: AQA states a theoretical understanding of both end positions is required, and AQA pseudo-code on the paper may present REPEAT…UNTIL for you to read and trace.

Definite (count-controlled) = FOR…ENDFOR, repeats a known number of times.
Indefinite (condition-controlled) = repeats until a condition is met, count unknown in advance.
WHILE tests BEFORE the body → may run ZERO times.
REPEAT…UNTIL tests AFTER the body → always runs AT LEAST ONCE.
Converting WHILE to REPEAT requires INVERTING the condition.
Theoretical understanding of both is required even if your language lacks one.

See the full worked example for programming concepts →

Nested iteration — a loop inside a loop

The inner loop runs completely for every single iteration of the outer loop.

The specification gives this exact example of nested iteration:

WHILE NotSolved
    … Instructions here ...
    FOR i ← 1 TO 5
        … Instructions here …
    ENDFOR
    … Instructions here …
ENDWHILE

The rule that governs everything: the inner loop completes its FULL cycle for EVERY single iteration of the outer loop.

FOR row ← 1 TO 3
    FOR col ← 1 TO 4
        OUTPUT row, col
    ENDFOR
ENDFOR

Outer loop: 3 iterations
Inner loop: 4 iterations each time
Total outputs: 3 × 4 = 12

The order is: (1,1) (1,2) (1,3) (1,4) (2,1) (2,2) (2,3) (2,4) (3,1) (3,2) (3,3) (3,4).

Multiply to find the total. This is the standard exam calculation — and it links straight to 3.1.2, because nested loops are why bubble sort's work grows with roughly n × n.

Where nested iteration is genuinely needed

Situation	Why nesting
Processing a 2D array (3.2.6)	Outer loop for rows, inner loop for columns
Printing a grid or times table	Outer for each line, inner for each item on the line
Bubble sort (3.1.4)	Outer for passes, inner for the pairs within a pass
Comparing every item with every other	Outer picks one, inner compares it to all the rest

Nested loops with a validated input inside

Combining what you have learned so far — this is the shape of a high-tariff Paper 1 answer:

FOR student ← 1 TO 30
    REPEAT
        OUTPUT 'Enter mark (0-100)'
        mark ← STRING_TO_INT(USERINPUT)
    UNTIL mark ≥ 0 AND mark ≤ 100

    total ← total + mark
ENDFOR

Here a definite outer loop (30 students, known) contains an indefinite inner loop (validation, unknown attempts). Choosing the right loop type for each level is precisely the judgement examiners are testing.

AQA tip. Indentation is not decoration here — with two or three levels of nesting, an unindented answer becomes genuinely unmarkable. Indent every level by a consistent amount and make sure each ENDFOR/ENDWHILE lines up with its opening statement.

The inner loop runs completely for EVERY iteration of the outer loop.
Total iterations = outer count × inner count.
Used for 2D arrays, grids, bubble sort, and all-pairs comparisons.
A definite outer loop often contains an indefinite validation loop — choose each deliberately.
Indent every level so the logic flow is identifiable.

See the full worked example for programming concepts →

Meaningful identifier names

An explicit specification requirement covering variables, constants AND subroutines.

The specification states: "Use meaningful identifier names and know why it is important to use them", and clarifies that "identifier names include names for variables, constants and subroutine names."

What makes a name meaningful

# Poor — no reader can tell what these hold
x ← 24
y ← 0.2
FOR a ← 1 TO x
    y2 ← y2 + a
ENDFOR

# Good — the code explains itself
numStudents ← 24
CONSTANT VAT_RATE ← 0.2
FOR studentNumber ← 1 TO numStudents
    totalMarks ← totalMarks + studentNumber
ENDFOR

Why it matters — the reasons that score

Reason	Explanation
Readability	Anyone reading the code — including you, months later — can understand what each value represents without tracing back to where it was set
Maintainability	Easier to modify and extend safely, because the purpose of each variable is obvious
Fewer errors	You are far less likely to use the wrong variable by mistake when the names describe their contents
Easier debugging	When something goes wrong, meaningful names make it obvious which variable is misbehaving
Team working	Other programmers can pick up and continue the work without needing it explained

The exam-specific reason

AQA states that when writing code in an exam, students "will need to ensure they use meaningful identifier names, use suitable data types and that all logic flow is clearly identifiable to examiners."

In other words: it is a marked requirement, not a style preference. totalScore genuinely protects marks that t puts at risk.

Sensible conventions

Describe what it holds: numberOfPlayers, not n.
Use UPPER_CASE for constants: MAX_ATTEMPTS, VAT_RATE.
Loop counters i and j are conventionally acceptable for simple counting — but row and col are clearer in nested loops and cost nothing.
No spaces in identifier names — use camelCase (totalScore) or underscores (total_score) consistently.

AQA tip. If a question asks why meaningful names matter, give two developed reasons rather than five one-word ones. "It makes the program easier to maintain, because a programmer returning to the code later can tell what each variable stores without tracing back through the program" is worth more than a list.

Identifier names cover variables, constants AND subroutines.
Reasons: readability, maintainability, fewer errors, easier debugging, easier team working.
AQA marks it — 'meaningful identifier names' is an explicit exam requirement.
Constants conventionally use UPPER_CASE.
Give two DEVELOPED reasons rather than a list of one-word ones.

See the full worked example for programming concepts →

Quick recap

The three combining principles are sequence, selection and iteration.
A variable's value can change; a constant's cannot change while the program runs.
Named constants: easy to update in one place, cannot be changed accidentally, and make code self-documenting.
Assignment ← means evaluate the right-hand side and store it in the left-hand side.
Definite (count-controlled) iteration = FOR; indefinite (condition-controlled) = WHILE or REPEAT.
WHILE tests before the body (may run zero times); REPEAT…UNTIL tests after (always runs at least once).
Converting between WHILE and REPEAT requires inverting the condition.
In nested iteration the inner loop runs fully for every outer iteration — multiply for the total.
Meaningful identifier names cover variables, constants and subroutines, and are an explicit AQA requirement.

Memorise this

Verbatim phrases and definitions Cambridge mark schemes credit.

The three combining principles: sequence, selection, iteration.
Variable = value CAN change. Constant = value CANNOT change while the program runs.
Named constants: update in one place, cannot be changed by accident, self-documenting.
Definite = count-controlled = FOR…ENDFOR (known number of repeats).
Indefinite = condition-controlled = WHILE…ENDWHILE or REPEAT…UNTIL (repeats unknown in advance).
WHILE: condition at the START → body may run ZERO times.
REPEAT…UNTIL / DO…WHILE: condition at the END → body ALWAYS runs at least ONCE.
Nested iteration: total iterations = outer × inner.
A theoretical understanding of BOTH condition positions is required regardless of the taught language.

How it’s examined

3.2.2 is the largest subtopic in the specification and is assessed on Paper 1, where it underpins almost every question. Expect it in four shapes. (1) Recall, 1–2 marks: define variable/constant, name the three combining principles, state which iteration type suits a scenario (AO1). (2) Compare, 2–4 marks: the highest-frequency item is the difference between condition-at-the-start and condition-at-the-end iteration — the mark is for zero times versus at least once (AO1/AO2). (3) Trace and count, 3–6 marks: nested-loop questions asking how many times a statement executes (multiply outer × inner), or trace tables through loops with selection inside (AO2). (4) Write code, 4–12 marks: the biggest mark block on the paper, where you must choose the right loop type, nest correctly, use meaningful identifier names and suitable data types, and indent so the logic flow is identifiable (AO3). Two boundaries matter: AQA requires theoretical understanding of both iteration end positions regardless of the language taught, so Python centres must still handle REPEAT…UNTIL on the paper; and 'use meaningful identifier names' is a stated exam requirement that appears in mark schemes, not a style suggestion.

Sources: AQA GCSE Computer Science 8525 specification (v1.3, 16 June 2025) — 3.2.2 Programming concepts; AQA GCSE Computer Science 8525 standard pseudo-code reference document; AQA GCSE Computer Science Paper 1 past papers, mark schemes and examiner reports. Last reviewed 2026-07-28.

Take this whole topic with you

Step-by-step worked examples — Programming concepts

Step-by-step solutions to past-paper-style questions on programming concepts, written exactly the way a tutor would explain them at the board.

Question type:

1Identify the programming constructs used (3 marks)
Getting startedIdentify & classify• Paper 1 style — 3 marks (AO2)• sequence, selection, iteration, identify
Question
Look at the algorithm below. Name the programming construct used at each of lines 2, 4 and 5. (3 marks)

1 total ← 0 2 FOR i ← 1 TO 10 3 num ← USERINPUT 4 IF num > 0 THEN 5 total ← total + num 6 ENDIF 7 ENDFOR 8 OUTPUT total
Step-by-step solution
1. Step 1
  Line 2 — FOR i ← 1 TO 10 repeats a block of statements a known number of times, so this is iteration (specifically definite / count-controlled iteration).
2. Step 2
  Line 4 — IF num > 0 THEN uses a condition to decide whether the next statement runs, so this is selection.
3. Step 3
  Line 5 — total ← total + num stores a value into a variable, so this is assignment.
Answer
Line 2: iteration — specifically definite (count-controlled) iteration, because it repeats a known number of times (1). Line 4: selection — a condition decides whether the following statement is executed (1). Line 5: assignment — a value is calculated and stored in the variable total (1). (3)
Examiner tip
Naming the iteration type as 'definite' or 'count-controlled' adds precision and is safer if the question asks you to be specific. Line 5 is assignment, not 'addition' — the arrow is what makes it an assignment statement.
2Explain the difference between a variable and a constant (4 marks)
Getting startedIdentify & classify• Paper 1 style — 4 marks (AO1)• variable, constant, compare
Question
Explain the difference between a variable and a constant, and give one example of data suited to each. (4 marks)
Step-by-step solution
1. Step 1
  Variable definition. A named location in memory whose value can change while the program is running.
2. Step 2
  Constant definition. A named location in memory whose value is fixed when the program is written and cannot change while the program runs.
3. Step 3
  Variable example. A running score in a game — it changes every time the player scores.
4. Step 4
  Constant example. The VAT rate (0.20) or the value of pi — fixed values that should never be altered by the program.
Answer
A variable is a named location in memory whose value can change while the program is running (1) — for example a player's score in a game, which increases each time they score points (1). A constant is a named location in memory whose value is set when the program is written and cannot be changed while the program runs (1) — for example the VAT rate of 0.20, which stays the same throughout (1). (4)
Examiner tip
The phrase 'while the program is running' is doing important work in both definitions and is what distinguishes them. A constant's value can be changed by a programmer editing the source code — what it cannot do is change during execution.
3State the difference between WHILE and REPEAT (3 marks)
Getting startedIdentify & classify• Paper 1 style — 3 marks (AO1)• while, repeat, iteration, compare
Question
Both structures below are examples of indefinite iteration. Explain the difference between them. (3 marks)

WHILE NotSolved REPEAT … Instructions … … Instructions … ENDWHILE UNTIL Solved
Step-by-step solution
1. Step 1
  Where the condition is tested. In the WHILE structure the condition is tested before the loop body runs; in the REPEAT structure it is tested after the body has run.
2. Step 2
  The consequence for WHILE. Because the test comes first, if the condition is already false at the start, the body runs zero times.
3. Step 3
  The consequence for REPEAT. Because the test comes last, the body always runs at least once, whatever the condition.
Answer
In the WHILE structure the condition is tested at the start, before the loop body is executed; in the REPEAT structure it is tested at the end, after the body has been executed (1). This means the body of the WHILE loop may run zero times, if the condition is already false when the loop is first reached (1), whereas the body of the REPEAT loop always runs at least once, because it executes before the condition is ever checked (1). (3)
Examiner tip
The 'zero times versus at least once' contrast is the mark scheme answer and must appear explicitly. Note also that the conditions are logical opposites: WHILE continues while its condition is true, whereas REPEAT…UNTIL continues while its condition is false.
4Explain why a programmer uses named constants (4 marks)
Building confidenceWord problem• Paper 1 style — 4 marks (AO1/AO2)• constant, explain, maintainability
Question
A program calculates ticket prices and uses the value 0.20 for the VAT rate in eleven different places. Explain two advantages of declaring VAT_RATE as a named constant instead. (4 marks)
Step-by-step solution
1. Step 1
  Advantage 1 — a single point of change. If VAT changes to 0.22, only the one constant declaration needs editing rather than all eleven places.
2. Step 2
  Develop it with the consequence. Editing eleven separate places risks missing one, which would leave the program calculating some prices at the old rate — a bug that is easy to introduce and hard to spot.
3. Step 3
  Advantage 2 — readability. price * VAT_RATE states its own purpose, whereas price * 0.20 forces the reader to work out what 0.20 represents.
4. Step 4
  Develop it. Self-documenting code is easier to maintain and debug, especially for another programmer or for the original author months later.
Answer
Advantage 1 — easier to update. If the VAT rate changes, the programmer only needs to edit the single constant declaration rather than all eleven occurrences of 0.20 (1). Editing eleven separate places risks missing one, which would leave part of the program using the old rate and produce inconsistent, incorrect prices that are difficult to trace (1).

Advantage 2 — the code is easier to read and maintain. price * VAT_RATE clearly states what the calculation is doing, whereas price * 0.20 requires the reader to work out what the number means (1). This makes the program easier for another programmer — or the original author returning to it later — to understand, modify and debug correctly (1).

(A third valid advantage: the value cannot be accidentally changed while the program is running, so it stays consistent throughout.) (4)
Examiner tip
Two marks per advantage: state it, then develop it with a consequence. Listing four advantages with no development typically caps at 2. The 'missing one occurrence' point is the strongest development available because it names a specific, realistic bug.
5Write nested selection for a scenario (5 marks)
Building confidenceMulti-step problem• Paper 1 style — 5 marks (AO3)• nested-selection, write-algorithm, if
Question
A cinema charges as follows. Under 5s go free. Everyone else pays £8, but members get £2 off. Write an algorithm using pseudo-code that inputs the customer's age and whether they are a member, then outputs the price they must pay. (5 marks)
Step-by-step solution
1. Step 1
  Identify the structure. There is an outer decision (under 5 or not) and, inside the 'not under 5' branch, a second decision (member or not). That is nested selection.
2. Step 2
  Get the inputs. Age must be converted to an integer; membership is naturally a Boolean.
3. Step 3
  Outer selection. IF age < 5 THEN price ← 0. Note the boundary: 'under 5' means < 5, so a 5-year-old pays.
4. Step 4
  Inner selection inside the ELSE. Standard price is 8; members pay 8 − 2 = 6.
5. Step 5
  Output after the selection, so a price is printed exactly once whichever branch was taken.
Answer
OUTPUT 'Enter your age' age ← STRING_TO_INT(USERINPUT) OUTPUT 'Are you a member?' isMember ← USERINPUT IF age < 5 THEN price ← 0 ELSE IF isMember = True THEN price ← 6 ELSE price ← 8 ENDIF ENDIF OUTPUT 'Price to pay: ', price

Marks: age input obtained and converted (1); outer selection correctly testing age < 5 and setting price to 0 (1); nested selection inside the ELSE branch (1); correct prices of 6 for members and 8 for non-members (1); output placed after the selection so exactly one price is displayed (1). (5)
Examiner tip
The boundary is the discriminator: 'under 5s go free' means age < 5, so a child who has just turned 5 pays. Writing age <= 5 is a classic off-by-one logic error. A compound-condition version using IF age >= 5 AND isMember THEN is equally acceptable provided all three cases are handled correctly.
6Count the iterations of a nested loop (4 marks)
Building confidenceDirect calculation• Paper 1 style — 4 marks (AO2)• nested-iteration, count, trace
Question
Look at the algorithm below.

count ← 0 FOR row ← 1 TO 4 FOR col ← 1 TO 6 count ← count + 1 ENDFOR ENDFOR OUTPUT count

(a) State how many times the statement count ← count + 1 is executed. (b) State the value output. (c) Explain how you worked this out. (4 marks)
Step-by-step solution
1. Step 1
  Understand the rule. The inner loop runs completely for every single iteration of the outer loop.
2. Step 2
  Count each loop. The outer loop runs 4 times (row = 1, 2, 3, 4). The inner loop runs 6 times (col = 1 to 6) for each of those.
3. Step 3
  Multiply: 4 × 6 = 24 executions.
  $4 \times 6 = 24$
4. Step 4
  The output. count starts at 0 and is incremented once per execution, so the value output is 24.
Answer
(a) The statement is executed 24 times (1). (b) The value output is 24 (1). (c) The inner loop runs completely for every iteration of the outer loop (1). The outer loop runs 4 times and the inner loop runs 6 times within each of those, so the total is 4 × 6 = 24 (1). (4)
Examiner tip
The multiplication is the whole idea — nested loop counts multiply, they do not add. A common wrong answer is 10 (4 + 6). This is also the mechanism behind bubble sort's poor efficiency in 3.1.2, where n nested inside n produces roughly n × n comparisons.
7Convert a WHILE loop into a REPEAT loop (6 marks)
StretchMulti-step problem• Paper 1 style — 6 marks (AO2/AO3)• while, repeat, convert, invert-condition
Question
Rewrite the algorithm below using a REPEAT…UNTIL loop instead of a WHILE loop, so that it behaves identically. Explain the change you had to make to the condition, and state one situation in which the two versions would not behave identically. (6 marks)

password ← USERINPUT WHILE password ≠ 'letmein' OUTPUT 'Incorrect, try again' password ← USERINPUT ENDWHILE OUTPUT 'Access granted'
Step-by-step solution
1. Step 1
  Spot the structure. The WHILE version obtains the first input before the loop, then re-prompts inside it. A REPEAT loop tests at the end, so the input can move inside the loop and the duplicated line before it disappears.
2. Step 2
  Invert the condition. WHILE keeps looping while its condition is true (password ≠ 'letmein'). REPEAT…UNTIL keeps looping until its condition becomes true, so the condition must be inverted to password = 'letmein'.
3. Step 3
  Handle the error message. In the WHILE version the message only appears after a wrong attempt. In the REPEAT version the input happens first, so the message needs a guard — or it can simply be omitted and the prompt reworded.
4. Step 4
  Write the converted version with the input inside the loop and the inverted condition at the end.
5. Step 5
  The situation where they differ. If the correct password were somehow already stored in password before the loop, the WHILE version would run its body zero times, whereas REPEAT would still execute its body once before testing — asking for input unnecessarily.
Answer
REPEAT OUTPUT 'Enter the password' password ← USERINPUT IF password ≠ 'letmein' THEN OUTPUT 'Incorrect, try again' ENDIF UNTIL password = 'letmein' OUTPUT 'Access granted'

The change to the condition. The WHILE loop continues while its condition is true (password ≠ 'letmein'), whereas REPEAT…UNTIL continues until its condition becomes true (1). The condition therefore had to be inverted, from ≠ to = (1).

Where they would differ. The WHILE version tests before running its body, so if password already held 'letmein' when the loop was reached, the body would execute zero times (1). The REPEAT version tests after its body, so it would always execute at least once, prompting the user for input even though the correct value was already stored (1).

Marks: input moved inside the loop (1); correctly inverted condition on the UNTIL line (1); plus the four explanation marks above. (6)
Examiner tip
Two things separate a full-mark answer. First, the inversion of the condition — candidates routinely copy ≠ across unchanged, producing a loop that exits immediately on a wrong password. Second, articulating the zero-times-versus-at-least-once difference in terms of this specific algorithm rather than as a general statement.
8Choose and justify the right iteration type (6 marks)
StretchWord problem• Paper 1 style — 6 marks (AO3)• definite, indefinite, justify, iteration
Question
A program must: (a) ask a teacher how many students are in the class, then read in that many test marks; and (b) for each mark, keep asking until a valid mark between 0 and 100 is entered.

State which type of iteration is most suitable for each part and justify your choices. (6 marks)
Step-by-step solution
1. Step 1
  Part (a) — the count becomes known. Once the teacher has entered the class size, the exact number of repetitions is known before the loop starts.
2. Step 2
  So (a) needs definite (count-controlled) iteration — a FOR loop running from 1 to the class size.
3. Step 3
  Part (b) — the count cannot be known. How many times a user will type an invalid mark is impossible to predict; it could be zero further attempts or many.
4. Step 4
  So (b) needs indefinite (condition-controlled) iteration, repeating until the entered value passes the range check.
5. Step 5
  Specify which end the condition goes. It must be condition at the end (REPEAT…UNTIL), because you cannot test a mark before you have obtained one — the body must run at least once.
6. Step 6
  Note the combination. The indefinite validation loop sits nested inside the definite outer loop.
Answer
(a) Definite (count-controlled) iteration — a FOR loop (1). Once the teacher has entered the class size, the exact number of repetitions is known before the loop begins, which is precisely the situation count-controlled iteration is designed for (1). The loop can simply run from 1 to the number of students (1).

(b) Indefinite (condition-controlled) iteration, with the condition at the end (REPEAT…UNTIL) (1). The number of attempts a user will take to enter a valid mark cannot be known in advance — it might be first time, or it might take several tries — so a count-controlled loop cannot be used (1). The condition must be at the end because the program has to obtain a mark before it can test whether it is valid, so the body must execute at least once (1).

The validation loop is nested inside the FOR loop, so each of the students' marks is validated in turn. (6)
Examiner tip
The final mark — justifying condition-at-the-end specifically — is the one most often missed. The reasoning is concrete: you cannot test a value you have not yet obtained, so a WHILE loop would need a dummy initial value to work around the problem. This question is the archetype for how AQA tests iteration choice.
9Rewrite a program with meaningful identifier names (6 marks)
StretchMulti-step problem• Paper 1 style — 6 marks (AO2/AO3)• identifier-names, constants, readability
Question
The algorithm below calculates the total cost of a booking, including a 20% service charge, for a group of people. Rewrite it using meaningful identifier names and a named constant, then explain two reasons why this matters. (6 marks)

a ← USERINPUT b ← 12.50 c ← a * b d ← c * 0.20 e ← c + d OUTPUT e
Step-by-step solution
1. Step 1
  Work out what each variable holds by reading the calculations: a is the number of people, b is the price per person, c the subtotal, d the service charge and e the final total.
2. Step 2
  Rename each one descriptively: numberOfPeople, pricePerPerson, subtotal, serviceCharge, totalCost.
3. Step 3
  Convert the fixed values into named constants. 12.50 and 0.20 are both fixed rates, so PRICE_PER_PERSON and SERVICE_CHARGE_RATE should be constants in UPPER_CASE.
4. Step 4
  Convert the input, since USERINPUT returns a string and the number of people is used in a calculation.
5. Step 5
  Give two developed reasons — readability/maintainability and reduced errors — each with a consequence rather than a bare assertion.
Answer
CONSTANT PRICE_PER_PERSON ← 12.50 CONSTANT SERVICE_CHARGE_RATE ← 0.20 OUTPUT 'How many people are in the group?' numberOfPeople ← STRING_TO_INT(USERINPUT) subtotal ← numberOfPeople * PRICE_PER_PERSON serviceCharge ← subtotal * SERVICE_CHARGE_RATE totalCost ← subtotal + serviceCharge OUTPUT 'Total cost: ', totalCost

Reason 1 — the program is far easier to read and maintain. A name such as serviceCharge states exactly what the value represents, whereas d tells the reader nothing (1). Any programmer returning to this code later can understand it immediately, rather than having to trace back through every calculation to work out what each letter stands for (1).

Reason 2 — fewer errors are made. With meaningful names, using the wrong variable becomes obvious — writing subtotal + subtotal instead of subtotal + serviceCharge reads as clearly wrong, whereas c + c instead of c + d looks perfectly plausible (1). Using named constants also means the service charge rate is defined in one place, so if it changes there is no risk of updating some occurrences and missing others (1).

Marks: all variables sensibly renamed (1); both fixed values declared as named constants (1); plus the four explanation marks above. (6)
Examiner tip
AQA states that exam code must use meaningful identifier names, suitable data types and clearly identifiable logic flow — so this is a marked requirement rather than a matter of taste. Full marks need developed reasons: the second half of each point (the consequence) is where two of the four explanation marks live.

Model Answers — Programming concepts

High-scoring sample answers for programming concepts on the AQA GCSE 8525 paper, with examiner-style notes mapping each response to the mark scheme and assessment objectives.

Question 1
Paper 1 style — AO13 marks
State the three combining principles that are basic to all high-level imperative programming languages. (3 marks)
Model answer
Sequence (1), selection (1) and iteration (1).
Why this scores
One mark each. 'Repetition' is accepted for iteration and 'choice' for selection, as the specification itself uses both pairs of terms. 'Subroutine' is not one of the three — it is a separate statement type in 3.2.2.
Question 2
Paper 1 style — AO12 marks
State what is meant by definite iteration and by indefinite iteration. (2 marks)
Model answer
Definite (count-controlled) iteration repeats a block of statements a known number of times, decided before the loop begins (1). Indefinite (condition-controlled) iteration repeats a block of statements until a condition is met, so the number of repetitions is not known in advance (1).
Why this scores
The contrast that earns both marks is 'known number of times' against 'not known in advance'. Giving the alternative names — count-controlled and condition-controlled — is a useful safeguard since questions may use either term.
Question 3
Paper 1 style — AO1/AO22 marks
A program contains the statement total ← total + 5. Explain what this statement does. (2 marks)
Model answer
It takes the current value stored in total and adds 5 to it (1), then stores the result back into total, replacing the previous value (1). If total held 12 before the statement, it holds 17 afterwards.
Why this scores
This is an assignment, not an equation — as a piece of mathematics it would be impossible. Reading assignment right-to-left ('work out the right, store it in the left') is the habit that prevents this confusion.
Question 4
Paper 1 style — AO24 marks
Explain why the body of a WHILE loop might never be executed, and give an example of when this behaviour is useful. (4 marks)
Model answer
A WHILE loop tests its condition before the body is executed (1). If that condition is already false the first time it is reached, the body is skipped entirely and the loop ends immediately, so it runs zero times (1).

This is useful when it would be wrong to perform the action even once. For example, a loop that processes items in a shopping basket should do nothing at all if the basket is empty (1) — a condition-at-the-end loop would try to process a first item that does not exist, causing an error or producing incorrect output (1).
Why this scores
The example is what lifts this from 2 marks to 4. Any scenario where acting on zero items must be safe will do: an empty list, a queue with no jobs waiting, a file containing no records.
Question 5
Paper 1 style — AO24 marks
Complete a trace of the algorithm below and state what is output. (4 marks)
```
total ← 0
FOR i ← 1 TO 3
    FOR j ← 1 TO 2
        total ← total + (i * j)
    ENDFOR
ENDFOR
OUTPUT total
```
Model answer

i j i × j total
— — — 0
1 1 1 1
1 2 2 3
2 1 2 5
2 2 4 9
3 1 3 12
3 2 6 18

OUTPUT: 18

Marks: correct order of the i and j pairs (1); correct i × j values (1); correct running total column (1); correct output of 18 (1).
Why this scores
The order of iteration is the key: j completes its full cycle for every single value of i, giving the pairs (1,1) (1,2) (2,1) (2,2) (3,1) (3,2). Six rows are required — writing only three, one per value of i, is the most common error.
Question 6
Paper 1 style — AO34 marks
A student writes the grading algorithm below, but every student with a score of 85 is awarded a Pass rather than a Distinction. Explain why, and state how to fix it. (4 marks)
```
IF score ≥ 40 THEN
    grade ← 'Pass'
ELSE IF score ≥ 55 THEN
    grade ← 'Merit'
ELSE IF score ≥ 70 THEN
    grade ← 'Distinction'
ENDIF
```
Model answer
The conditions are tested in order, and as soon as one is true the remaining branches are skipped (1). A score of 85 satisfies the very first condition, score ≥ 40, so grade is set to 'Pass' and the Merit and Distinction branches are never reached (1).

To fix it, the conditions must be tested from the most restrictive to the least restrictive (1):

IF score ≥ 70 THEN grade ← 'Distinction' ELSE IF score ≥ 55 THEN grade ← 'Merit' ELSE IF score ≥ 40 THEN grade ← 'Pass' ELSE grade ← 'Fail' ENDIF

(1 for the corrected ordering, with the added ELSE handling scores below 40.)
Why this scores
This is a logic error, not a syntax error — the program runs perfectly and simply produces the wrong grade, which links to 3.2.11. The general principle is worth memorising: in a chain of ELSE IF tests, order from most restrictive to least. Adding the final ELSE for scores under 40 is a further credit-worthy improvement.
Question 7
Paper 1 style — AO38 marks
A quiz program must ask 5 questions. For each question the user enters an answer between 1 and 4, and the program must keep asking until a valid number is entered. The program should count how many answers were correct, using the array correctAnswers which holds the right answer for each question.

Write an algorithm using pseudo-code. (8 marks)
Model answer
CONSTANT NUM_QUESTIONS ← 5 score ← 0 FOR question ← 1 TO NUM_QUESTIONS REPEAT OUTPUT 'Question ', question, ' — enter your answer (1-4)' answer ← STRING_TO_INT(USERINPUT) IF answer < 1 OR answer > 4 THEN OUTPUT 'Invalid — please enter a number from 1 to 4' ENDIF UNTIL answer ≥ 1 AND answer ≤ 4 IF answer = correctAnswers[question] THEN score ← score + 1 ENDIF ENDFOR OUTPUT 'You scored ', score, ' out of ', NUM_QUESTIONS

Marks: score initialised to 0 before the loop (1); definite outer loop running 5 times (1); indefinite (condition-at-the-end) inner loop for validation (1); input obtained and converted inside the validation loop (1); correct range check using AND/OR (1); comparison of the answer against the array element (1); score incremented only when correct (1); final output placed after the outer loop (1). (8)
Why this scores
This is the archetypal high-tariff 3.2.2 question, combining definite iteration, indefinite iteration, nested selection, validation and an array. The three marks lost most often are: placing the output inside the loop so it prints five times; using an IF rather than a loop for validation, so an invalid answer is rejected but never re-requested; and forgetting to initialise score before the loop. Using a named constant for the number of questions is good practice and reinforces the constants requirement.
Question 8
Paper 1 style — AO1/AO26 marks
Compare definite and indefinite iteration, explaining when each should be used. Include in your answer the difference between placing the condition at the start and at the end of an indefinite loop. (6 marks)
Model answer
Definite (count-controlled) iteration repeats a block of statements a known number of times, fixed before the loop begins — for example FOR i ← 1 TO 10 (1). It should be used whenever the number of repetitions is known in advance, such as processing every element of an array of known size, or repeating an action a fixed number of times (1).

Indefinite (condition-controlled) iteration repeats until a condition is met, so the number of repetitions is not known in advance (1). It should be used when the number of repeats depends on something that happens while the program runs — for example validating user input, where you cannot predict how many attempts the user will need, or searching a list where you stop as soon as the item is found (1).

Condition at the start (WHILE…ENDWHILE) tests before the body executes, so the body may run zero times — appropriate when it could be wrong to perform the action even once, such as processing an empty list (1).

Condition at the end (REPEAT…UNTIL or DO…WHILE) tests after the body executes, so the body always runs at least once — appropriate when the action must happen before it can be tested, such as obtaining a value from the user before checking whether it is valid (1). (6)
Why this scores
A full-mark answer needs both what each is and when to use it, plus the start/end distinction with its zero-times-versus-at-least-once consequence. Note that AQA requires a theoretical understanding of both end positions regardless of the language taught — so Python centres must still be able to reason about REPEAT…UNTIL when it appears in AQA pseudo-code on the paper.
Question 9
Paper 1 style — AO38 marks
The algorithm below should output the 7 times table from 7 × 1 up to 7 × 12, but it does not work. Identify three errors, explain the effect of each, and write a corrected version. (8 marks)
```
1   i ← 1
2   WHILE i < 12
3       answer ← 7 * i
4       OUTPUT '7 x ', i, ' = ', answer
5   ENDWHILE
```
Model answer
Error 1 — the loop counter is never incremented. There is no i ← i + 1 anywhere inside the loop (1), so i remains 1 forever, the condition i < 12 is always true, and the program produces an infinite loop printing 7 x 1 = 7 endlessly (1).

Error 2 — the condition uses the wrong relational operator. i < 12 stops after i reaches 12, so the final line 7 x 12 = 84 would never be output (1). It should be i ≤ 12 (1).

Error 3 — definite iteration is the wrong tool omitted here. The number of repetitions is known in advance (12), so this should be a count-controlled FOR loop rather than a condition-controlled WHILE loop (1). Using a FOR loop also removes the possibility of Error 1 entirely, because the counter is incremented automatically (1).

Corrected version:

FOR i ← 1 TO 12 answer ← 7 * i OUTPUT '7 x ', i, ' = ', answer ENDFOR

(1 for a correct working algorithm; 1 for using definite iteration appropriately.) (8)
Why this scores
The missing increment causing an infinite loop is the headline error and must be identified with its consequence named. Error 2 is an off-by-one boundary error — < versus ≤ — which is exactly the reasoning tested by boundary test data in 3.2.11. The third point is a design judgement rather than a bug, and rewards recognising that the choice of loop type prevents a whole class of error.

i	j	i × j	total
—	—	—	0
1	1	1	1
1	2	2	3
2	1	2	5
2	2	4	9
3	1	3	12
3	2	6	18

Key Definitions and Keywords — Programming concepts

Definitions to memorise and the exact keywords mark schemes credit for programming concepts answers — sharpened from recent examiner reports for the 2026 AQA GCSE 8525 sitting.

Sequence
Examiner keyword
Statements being carried out one after another, in the order they are written. One of the three combining principles.
Related: Selection, Iteration
Selection
Examiner keyword
A construct in which a condition determines which statements are executed — IF…THEN…ELSE…ENDIF. Also called choice.
Example
IF score ≥ 40 THEN OUTPUT 'Pass' ELSE OUTPUT 'Fail' ENDIF
Related: Sequence, Iteration, Nested selection
Iteration
Examiner keyword
A construct in which statements are repeated. Also called repetition. Divided into definite (count-controlled) and indefinite (condition-controlled) iteration.
Related: Definite iteration, Indefinite iteration
Definite (count-controlled) iteration
Examiner keyword
Iteration that repeats a known number of times, decided before the loop begins. Written as FOR…ENDFOR.
Example
FOR i ← 1 TO 5 … ENDFOR
Related: Indefinite iteration, Iteration
Indefinite (condition-controlled) iteration
Examiner keyword
Iteration that repeats until a condition is met, where the number of repetitions is not known in advance. Written as WHILE…ENDWHILE (condition at the start) or REPEAT…UNTIL / DO…WHILE (condition at the end).
Related: Definite iteration, Condition at the start, Condition at the end
Condition at the start
Examiner keyword
An indefinite loop that tests its condition before executing the body (WHILE…ENDWHILE). The body may therefore run zero times.
Example
WHILE NotSolved … ENDWHILE
Related: Condition at the end, Indefinite iteration
Condition at the end
Examiner keyword
An indefinite loop that tests its condition after executing the body (REPEAT…UNTIL or DO…WHILE). The body therefore always runs at least once. A theoretical understanding is required even if the taught language does not support it.
Example
REPEAT … UNTIL Solved
Related: Condition at the start, Indefinite iteration, Validation
Variable
Examiner keyword
A named location in memory whose value can change while the program is running.
Example
score ← 0 ; score ← score + 10
Related: Constant, Assignment, Variable declaration
Constant
Examiner keyword
A named location in memory whose value is set when the program is written and cannot be changed while the program runs. Used so a fixed value can be updated in one place, cannot be altered accidentally, and is self-documenting.
Example
CONSTANT VAT_RATE ← 0.20
Related: Variable, Magic number
Magic number
A bare numeric value written directly into code with no explanation of what it represents. Replacing magic numbers with named constants makes code readable and maintainable.
Example
price * 0.20 (magic number) vs price * VAT_RATE (named constant)
Related: Constant
Assignment
Examiner keyword
Storing a value in a variable. In AQA pseudo-code it uses a left arrow ←, and is read right-to-left: evaluate the right-hand side, then store the result in the left-hand side.
Example
total ← total + 5
Related: Variable, Variable declaration
Variable declaration
Examiner keyword
Creating a variable by giving it a name so that memory can be reserved for it. In statically typed languages the data type is stated at the same time.
Related: Variable, Constant declaration
Constant declaration
Examiner keyword
Creating a named constant and giving it its fixed value. Conventionally written in UPPER_CASE to distinguish it from a variable.
Example
CONSTANT MAX_PLAYERS ← 4
Related: Constant
Nested selection
Examiner keyword
A selection statement placed inside another selection statement. The inner condition is only tested if the outer condition was met.
Example
IF GameWon THEN IF Score > HighScore THEN … ENDIF ENDIF
Related: Selection, Nested iteration
Nested iteration
Examiner keyword
A loop placed inside another loop. The inner loop runs completely for every single iteration of the outer loop, so the total number of iterations is outer × inner.
Example
FOR row ← 1 TO 4 / FOR col ← 1 TO 6 → 24 iterations
Related: Iteration, Nested selection, Two dimensional array
Identifier name
Examiner keyword
The name given to a variable, constant or subroutine. AQA requires meaningful identifier names in exam code so that the purpose of each item is clear and the logic flow is identifiable to examiners.
Example
numberOfStudents rather than n
Related: Variable, Constant, Subroutine
Subroutine
Examiner keyword
A named 'out of line' block of code that can be executed by writing its name in a program statement. One of the statement types listed in 3.2.2 and developed fully in 3.2.10.
Related: Identifier name, Structured programming
Infinite loop
Examiner keyword
A loop whose condition never becomes false, so it repeats forever. Most commonly caused by forgetting to change the variable that the loop condition depends on.
Example
WHILE i < 12 with no i ← i + 1 inside the loop.
Related: Iteration, Logic error

Common Mistakes and Misconceptions — Programming concepts

The traps other students keep falling into on programming concepts questions — taken from recent AQA GCSE 8525 examiner reports and mark schemes — and how to avoid them.

✕Saying that a WHILE loop and a REPEAT…UNTIL loop 'do the same thing', or being unable to state which one is guaranteed to run at least once.
AQA 8525 specification 3.2.2 additional information: 'A theoretical understanding of condition(s) at either end of an iterative structure is required, regardless of whether they are supported by the language(s) being used.'
Why it happens
In most everyday programs the two produce identical output, so the difference never shows up in classroom work — and many centres teach Python, which has no native condition-at-the-end construct at all.
How to avoid it
Anchor it to one sentence: WHILE tests first, so it may run ZERO times; REPEAT tests last, so it ALWAYS runs at least ONCE. Then remember why validation uses REPEAT — you cannot test a value before you have obtained one. AQA requires theoretical understanding of both regardless of your taught language.
✕Converting a WHILE loop to a REPEAT loop (or vice versa) without inverting the condition.
Loop-conversion questions are a recurring Paper 1 shape and mark schemes award a specific mark for the inverted condition.
Why it happens
The two structures look symmetrical, so students move the condition to the other end and copy it across unchanged, not noticing that WHILE means 'keep going while true' and UNTIL means 'keep going until true'.
How to avoid it
Say the loop out loud: WHILE password ≠ 'letmein' means keep looping while it is wrong; UNTIL password = 'letmein' means keep looping until it is right. Those are opposite conditions. Every conversion requires flipping the operator — ≠ becomes =, < becomes ≥, AND becomes OR.
✕Adding the two loop counts instead of multiplying them when asked how many times a nested statement executes.
This multiplication is also the mechanism behind bubble sort's poor efficiency in 3.1.2, where the comparison count grows with roughly n × n.
Why it happens
Students see two loops and instinctively total the iterations, without picturing that the inner loop restarts from the beginning on every single pass of the outer one.
How to avoid it
Fix the rule: the inner loop runs completely for EVERY iteration of the outer loop, so multiply. FOR row ← 1 TO 4 containing FOR col ← 1 TO 6 gives 4 × 6 = 24, not 10. Sanity-check by writing out the first few pairs: (1,1) (1,2) … (1,6) (2,1) …
✕Writing a WHILE loop without changing the variable the condition depends on, producing an infinite loop.
Missing-increment infinite loops are a standard error-identification question on Paper 1.
Why it happens
A FOR loop increments its counter automatically, so students who normally use FOR forget that a WHILE loop makes the increment their responsibility.
How to avoid it
Every time you write a WHILE, immediately ask: what inside this loop will eventually make the condition false? If nothing changes the tested variable, the loop can never end. Then trace two iterations by hand — an infinite loop becomes obvious within seconds.
✕Ordering ELSE IF conditions from least restrictive to most restrictive, so later branches can never be reached.
This produces a logic error rather than a syntax error — the program runs and silently gives wrong results, which links directly to 3.2.11.
Why it happens
It feels natural to work upwards from the lowest grade boundary, and the code looks perfectly reasonable — the bug only appears when a high value is tested, and it produces no error message.
How to avoid it
Order conditions from most restrictive to least restrictive: check score ≥ 70 before score ≥ 55 before score ≥ 40. Once a condition is true the remaining branches are skipped, so a low threshold placed first captures everything above it too. Always test your ordering with the highest possible value.
✕Using = for assignment in AQA pseudo-code, or confusing assignment with comparison inside a condition.
The AQA standard pseudo-code reference document uses ← exclusively for assignment; using = there makes an algorithm ambiguous.
Why it happens
Python and VB.NET both use = for assignment, and mathematics uses = for equality — so the single symbol carries two different meanings across the contexts students move between daily.
How to avoid it
In AQA pseudo-code, ← assigns and = compares. Read ← as 'becomes' or 'is set to': total ← total + 5 is 'total becomes total plus 5', which is an instruction, not a claim about equality. In a condition such as IF answer = 4 THEN you are asking a question, not storing anything.

Programming Concepts — AQA GCSE Computer Science 8525 (3.2.2)

Principle

What it means

AQA pseudo-code

Sequence

Statements are carried out one after another, in the order written

one line after another

Selection

A condition decides which statements run

IF…THEN…ELSE…ENDIF

Iteration

Statements are repeated

FOR…ENDFOR, WHILE…ENDWHILE, REPEAT…UNTIL

Reason

Explanation

Easy to update

If the VAT rate changes, you edit one line instead of hunting for every 0.20 scattered through the program

Prevents accidental change

The value cannot be altered by mistake while the program runs, so it stays consistent everywhere

Makes code readable

price * VAT_RATE explains itself; price * 0.20 makes the reader guess what 0.20 means

# Poor — what is 0.20? What is 4? A reader cannot tell. total ← price * 0.20 IF players > 4 THEN # Good — self-documenting, and each value is defined in one place CONSTANT VAT_RATE ← 0.20 CONSTANT MAX_PLAYERS ← 4 total ← price * VAT_RATE IF players > MAX_PLAYERS THEN

WHILE…ENDWHILE

REPEAT…UNTIL

Condition tested

Before the body

After the body

Minimum runs

Loop continues while

Condition is True

Condition is False

Loop stops when

Condition is False

Condition is True

Best for

When it may be wrong to run even once

When the body must run at least once (e.g. asking for input)

Situation

Why nesting

Processing a 2D array (3.2.6)

Outer loop for rows, inner loop for columns

Printing a grid or times table

Outer for each line, inner for each item on the line

Bubble sort (3.1.4)

Outer for passes, inner for the pairs within a pass

Comparing every item with every other

Outer picks one, inner compares it to all the rest

# Poor — no reader can tell what these hold x ← 24 y ← 0.2 FOR a ← 1 TO x y2 ← y2 + a ENDFOR # Good — the code explains itself numStudents ← 24 CONSTANT VAT_RATE ← 0.2 FOR studentNumber ← 1 TO numStudents totalMarks ← totalMarks + studentNumber ENDFOR

Reason

Explanation

Readability

Anyone reading the code — including you, months later — can understand what each value represents without tracing back to where it was set

Maintainability

Easier to modify and extend safely, because the purpose of each variable is obvious

Fewer errors

You are far less likely to use the wrong variable by mistake when the names describe their contents

Easier debugging

When something goes wrong, meaningful names make it obvious which variable is misbehaving

Team working

Other programmers can pick up and continue the work without needing it explained

OUTPUT 'Enter your age' age ← STRING_TO_INT(USERINPUT) OUTPUT 'Are you a member?' isMember ← USERINPUT IF age < 5 THEN price ← 0 ELSE IF isMember = True THEN price ← 6 ELSE price ← 8 ENDIF ENDIF OUTPUT 'Price to pay: ', price

REPEAT OUTPUT 'Enter the password' password ← USERINPUT IF password ≠ 'letmein' THEN OUTPUT 'Incorrect, try again' ENDIF UNTIL password = 'letmein' OUTPUT 'Access granted'

CONSTANT PRICE_PER_PERSON ← 12.50 CONSTANT SERVICE_CHARGE_RATE ← 0.20 OUTPUT 'How many people are in the group?' numberOfPeople ← STRING_TO_INT(USERINPUT) subtotal ← numberOfPeople * PRICE_PER_PERSON serviceCharge ← subtotal * SERVICE_CHARGE_RATE totalCost ← subtotal + serviceCharge OUTPUT 'Total cost: ', totalCost

i	j	i × j	total
—	—	—	0
1	1	1	1
1	2	2	3
2	1	2	5
2	2	4	9
3	1	3	12
3	2	6	18

i × j

total

—

CONSTANT NUM_QUESTIONS ← 5 score ← 0 FOR question ← 1 TO NUM_QUESTIONS REPEAT OUTPUT 'Question ', question, ' — enter your answer (1-4)' answer ← STRING_TO_INT(USERINPUT) IF answer < 1 OR answer > 4 THEN OUTPUT 'Invalid — please enter a number from 1 to 4' ENDIF UNTIL answer ≥ 1 AND answer ≤ 4 IF answer = correctAnswers[question] THEN score ← score + 1 ENDIF ENDFOR OUTPUT 'You scored ', score, ' out of ', NUM_QUESTIONS

Programming concepts

Detailed Study Notes

At a glance

What you’ll learn

The three combining principles

Variables, constants and assignment

Variable declaration

Constant declaration

Why use named constants? (an explicit spec requirement)

Assignment

Selection, including nested selection

Basic selection

Multi-way selection with ELSE IF

Nested selection — an IF inside an IF

Iteration: definite vs indefinite, and where the condition sits

Definite (count-controlled) iteration

Indefinite (condition-controlled) iteration

The difference that earns the marks

Why input validation naturally uses REPEAT

Nested iteration — a loop inside a loop

Where nested iteration is genuinely needed

Nested loops with a validated input inside

Meaningful identifier names

What makes a name meaningful

Why it matters — the reasons that score

The exam-specific reason

Sensible conventions

Quick recap

Memorise this

How it’s examined

Take this whole topic with you

1Identify the programming constructs used (3 marks)

2Explain the difference between a variable and a constant (4 marks)

3State the difference between WHILE and REPEAT (3 marks)

4Explain why a programmer uses named constants (4 marks)

5Write nested selection for a scenario (5 marks)

6Count the iterations of a nested loop (4 marks)

7Convert a WHILE loop into a REPEAT loop (6 marks)

8Choose and justify the right iteration type (6 marks)

9Rewrite a program with meaningful identifier names (6 marks)

Sequence

Selection

Iteration

Definite (count-controlled) iteration

Indefinite (condition-controlled) iteration

Condition at the start

Condition at the end

Variable

Constant

Magic number

Assignment

Variable declaration

Constant declaration

Nested selection

Nested iteration

Identifier name

Subroutine

Infinite loop

✕Saying that a WHILE loop and a REPEAT…UNTIL loop 'do the same thing', or being unable to state which one is guaranteed to run at least once.

✕Converting a WHILE loop to a REPEAT loop (or vice versa) without inverting the condition.

✕Adding the two loop counts instead of multiplying them when asked how many times a nested statement executes.

✕Writing a WHILE loop without changing the variable the condition depends on, producing an infinite loop.

✕Ordering ELSE IF conditions from least restrictive to most restrictive, so later branches can never be reached.

✕Using = for assignment in AQA pseudo-code, or confusing assignment with comparison inside a condition.

Programming concepts

Detailed Study Notes

At a glance

What you’ll learn

The three combining principles

Variables, constants and assignment

Variable declaration

Constant declaration

Why use named constants? (an explicit spec requirement)

Assignment

Selection, including nested selection

Basic selection

Multi-way selection with ELSE IF

Nested selection — an IF inside an IF

Iteration: definite vs indefinite, and where the condition sits

Definite (count-controlled) iteration

✕Using `=` for assignment in AQA pseudo-code, or confusing assignment with comparison inside a condition.