• Variables & Constants — named boxes that store data; variables can change, constants can't.
• Data Types — INTEGER, REAL, CHAR, STRING, BOOLEAN — the "shape" of data.
• Input & Output — how a program talks to the user (keyboard in, screen out).
• Sequence — code runs top to bottom, one line at a time, in order.
• Selection — IF and CASE statements that make decisions and branch the flow.
• Iteration — FOR, WHILE, REPEAT loops that repeat code.
• Totalling & Counting — running-total and counter patterns inside loops.
• String Handling — case conversion, length, substrings.
• Operators — arithmetic (+ - * /), relational (== > <), Boolean (AND OR NOT).
• Procedures & Functions — reusable named blocks of code; functions return a value, procedures don't.
• Local & Global Variables — where a variable "lives" and who can see it.
• Library Routines — pre-built, tested code like RANDOM() and ROUND().
• Maintaining Programs — writing readable, well-structured code that's easy to fix later.

What's actually going on here?

Think of your computer's memory as a giant wall of lockers. A variable is a labelled locker where you can put something in, take it out, and swap it for something else — as many times as you like while the program runs. The label (the identifier) never changes, but the contents can.

A constant is also a labelled locker, but it's sealed with a value at the start and never opened again for the rest of the program's life. This matters more than it sounds — if you use the literal number 3.142 for π in fifteen different places in your code and then discover you need more precision, you have to hunt down and change all fifteen. If you'd used CONSTANT PI ← 3.142 instead, you change it in exactly one place.

Naming rules for identifiers

Cambridge is picky about this, and it's an easy mark to lose. An identifier (the name of a variable, constant, procedure, or function) must:

• Be in mixed case — also called Pascal case, e.g. FirstName, not firstname or FIRSTNAME
• Only contain letters (A–Z, a–z) and digits (0–9)
• Start with a capital letter — and never start with a digit

Declaring a variable

DECLARE Age : INTEGER
DECLARE Price : REAL
DECLARE GameOver : BOOLEAN

score = int()   # whole number
cost = float()  # decimal number
light = bool()  # True/False only

Declaring a constant

CONSTANT PI ← 3.142
CONSTANT PASSWORD ← "letmein"
CONSTANT HIGHSCORE ← 9999

PI = 3.142
VAT = 0.20
PASSWORD = "letmein"

A data type tells the computer what kind of thing is being stored, which affects how much memory to allocate and what operations make sense on it. You wouldn't try to multiply someone's name by 2 — the data type system exists partly to catch that kind of nonsense.

A program that never receives input and never produces output is basically useless — it would run once and always give the identical result, unable to react to the outside world. Input/output (I/O) is how the program connects to reality.

• Input devices: keyboard (standard for text input), mouse, sensors, microphone.
• Output devices: monitor (standard for text output), speaker, printer.

INPUT Name
IF Name ← "James" OR Name ← "Rob" THEN
  OUTPUT "Love the name ", Name

name = input("Enter your name: ")
if name == "James" or name == "Rob":
    print("Love the name " + name)

This is the simplest concept in the whole chapter, and also one students underestimate. Sequence just means: the computer executes instructions in the exact order they're written, one at a time, top to bottom. There's no "skipping ahead" or "guessing what you meant."

The danger is that if you get the order wrong, the program can behave in a way that looks almost right but is subtly broken, or it crashes outright.

A sequencing bug in action

Here's a function meant to calculate the area of a rectangle. Spot the problem before reading on:

FUNCTION CalculateArea(length, width)
   RETURN area
   area ← length * width
END FUNCTION

This will crash (or return garbage) because RETURN area runs before area has ever been calculated. The line that assigns the value must come first:

FUNCTION CalculateArea(length, width)
   area ← length * width
   RETURN area
END FUNCTION

Selection is how a program makes decisions. Depending on whether a condition is true or false, the program takes a different path — like a fork in a road. This is what allows programs to validate data, react to user choices, and behave differently in different situations.

IF statements

Nested Selection

Nested just means "stored inside the other" — an IF statement placed entirely inside the body of another IF statement. This lets you check a second condition, but only if the first one was already true.

test_score = int(input("Enter a number: "))

if test_score > 40:
    if test_score > 70:
        result = "Distinction"
    elif test_score > 55:
        result = "Merit"
    else:
        result = "Pass"
else:
    result = "Fail"

print(result)

CASE statements

A CASE statement is a cleaner way to write selection when you're comparing one single variable against several possible fixed values — it's less useful when your conditions involve ranges or multiple different variables (that's when IF is better).

INPUT Move
CASE OF Move
  'W' : Position ← Position - 10
  'E' : Position ← Position + 10
  'A' : Position ← Position - 1
  'D' : Position ← Position + 1
  OTHERWISE OUTPUT "Beep"
ENDCASE

Iteration is repeating a line or block of code using a loop, so you don't have to copy-paste the same instructions over and over. There are three flavours: count-controlled, condition-controlled (two types), and nested.

Count-Controlled Loops (FOR)

Use this when you know exactly how many times the loop should run before it even starts.

Condition-Controlled Loops

Use this when you don't know in advance how many times the loop needs to run — instead, it keeps going until some condition becomes true (or false).

REPEAT
   INPUT Guess
UNTIL Guess = 42

WHILE Colour != "Red" DO
   INPUT Colour
ENDWHILE

# Python equivalent
while colour != "Red":
    colour = input("New colour")

Nested Iteration

A loop inside another loop. The inner loop completes its entire run for every single pass of the outer loop. This is exactly how multiplication tables, grids, and 2D arrays get processed.

outer_counter = 1
while outer_counter <= number:
    inner_counter = 1
    while inner_counter <= 10:
        product = outer_counter * inner_counter
        print(outer_counter, "x", inner_counter, "=", product)
        inner_counter = inner_counter + 1
    outer_counter = outer_counter + 1

These are two of the most exam-tested patterns in the whole syllabus, and they always follow the exact same shape:

1. Initialise a variable to 0, before the loop starts.
2. Update that variable inside the loop, once per iteration.
3. Output the final value, after the loop ends.

The only difference between totalling and counting is what happens in step 2: totalling adds the actual value each time; counting adds exactly 1 each time a condition is met (it doesn't care about the value, only whether something happened).

String manipulation means using code to modify, analyse, or extract information from text data. The three key operations tested are case conversion, length, and substrings.

Case Conversion

Length

Password ← "letmein"
IF LENGTH(Password) >= 8
   THEN OUTPUT "Password accepted"
   ELSE OUTPUT "Password too short"
ENDIF

(This outputs "Password too short" since "letmein" has only 7 characters.)

Substring

A substring pulls out a chunk of characters from a bigger string. Pseudocode uses (start position, length). Python uses [start:end] slicing instead.

An operator is a symbol that instructs the computer to perform a specific operation on one or more values. There are three families you need cold: arithmetic (maths), logical/relational (comparison), and Boolean (combining true/false conditions).

Arithmetic Operators

Logical (Relational) Operators

Boolean Operators

• AND — True only if both conditions are true.
• OR — True if one or both conditions are true.
• NOT — Flips the result (True becomes False, and vice versa).

score = int(input("Enter the score: "))
if score >= 90 and score <= 100:
    print("Grade: A")
elif score >= 80 and score < 90:
    print("Grade: B")
elif score >= 70 and score < 80:
    print("Grade: C")
elif score < 70:
    print("Fail")

As programs grow, cramming everything into one giant block of code becomes unmanageable. Sub-programs solve this by letting you package a sequence of instructions under one name, so you can reuse it, test it in isolation, and keep your main code short and readable.

Parameters are values passed into a sub-program, written in brackets after its name, e.g. FUNCTION TaxCalculator(pay, taxcode). A sub-program can take multiple parameters, or none at all.

Procedures

PROCEDURE calculate_area(length: INTEGER, width: INTEGER)
   area ← length * width
   OUTPUT "The area is ", area
ENDPROCEDURE

CALL calculate_area(5, 3)

# Python
def calculate_area(length, width):
    area = length * width
    print("The area is", area)

calculate_area(5, 3)

Functions

FUNCTION calculate_area(length: INTEGER, width: INTEGER)
   area ← length * width
   RETURN area
ENDFUNCTION

OUTPUT calculate_area(5, 3)

This is fundamentally about scope — where in the code a variable can be seen and used.

# LOCAL example — localVariable only exists inside printValue()
def printValue():
    localVariable = 10
    print("The value is:", localVariable)

printValue()

# GLOBAL example — globalVariable can be seen by any function
globalVariable = 10

def printValue():
    global globalVariable
    print("The value is:", globalVariable)

printValue()

A library routine is ready-made, already-tested code that you can just call instead of writing it yourself from scratch. Why reinvent a random number generator when a reliable, tested one already exists in a library?

Cost ← 1.9556
OUTPUT ROUND(Cost, 2)
# Outputs 1.96

Code isn't just written once — it gets read, fixed, and extended by other people (or by you, six months later, having forgotten everything). A program that's easy to maintain uses consistent techniques that make its structure and intent obvious at a glance.

• Layout — clear spacing between logical sections of code.
• Indentation — consistently shows which lines belong inside which block.
• Comments — explain why the code does something, not just what.
• Meaningful variable names — studentAge beats x every time.
• White space — blank lines to visually separate ideas.
• Sub-programs — functions/procedures used where possible instead of repeating code.

Variable

An identifier whose value CAN change during a program's execution.

Constant

An identifier whose value is set once and never changes.

Casting

Converting a value from one data type to another (e.g. string → integer).

Sequence

Instructions executed one at a time, in the exact order written.

Selection

Changing the flow of a program based on the result of a condition (IF / CASE).

Iteration

Repeating a block of code using a loop (FOR / WHILE / REPEAT).

Count-controlled loop

Repeats a fixed, known number of times — uses FOR.

Condition-controlled loop

Repeats until a condition is met — uses WHILE (pre-condition) or REPEAT (post-condition).

Nested

A statement stored entirely inside another statement of the same type.

Function

A sub-program that RETURNS a value; called within an expression.

Procedure

A sub-program that does NOT return a value; invoked using CALL.

Parameter

A value passed into a sub-program, written in brackets after its name.

Local variable

Declared inside a sub-program; only accessible within that block; destroyed when the block ends.

Global variable

Declared at the outermost level; accessible from anywhere in the program.

Library routine

Pre-written, reusable, pre-tested code (e.g. RANDOM(), ROUND()).

Tick off each concept once you're confident you could explain it without looking back.

• I can declare a variable and a constant correctly in pseudocode and Python.
• I know the naming rules for identifiers (mixed case, no digit start).
• I can name the correct data type for a given piece of data.
• I understand what "casting" means and when it's needed.
• I understand sequence and why order-of-instructions matters.
• I can write an IF-THEN-ELSE statement, including nested IFs.
• I know when to use a CASE statement instead of IF.
• I can write a count-controlled (FOR) loop with and without STEP.
• I know the difference between WHILE (pre-condition) and REPEAT (post-condition).
• I can write nested loops and trace through what they output.
• I can write a totalling pattern and a counting pattern from scratch.
• I can convert string case, find length, and extract a substring.
• I know all arithmetic, logical, and Boolean operators in both pseudocode and Python.
• I can explain the difference between a function and a procedure.
• I can write and call a procedure/function with parameters.
• I understand local vs global scope and why it matters.
• I know at least two library routines and what problem they solve.
• I can list techniques that make a program easy to maintain.