Programming Concepts

A variable is a named storage location whose value CAN CHANGE while the program runs. Use for things that may take different values over time — user input, counters, totals, current state.

A constant is a named storage location whose value DOES NOT CHANGE after it's set. Use for fixed values:

• Mathematical constants (π = 3.14159...).
• Configuration limits (MAX_USERS = 100, VAT_RATE = 0.20).
• Magic numbers (DAYS_IN_WEEK = 7) — replacing them with named constants makes code self-documenting.

Why prefer constants when possible.

• Self-documenting (circumference ← 2 * PI * radius reads better than circumference ← 2 * 3.14159 * radius).
• Single source of truth — change in one place if the value updates.
• Compiler / interpreter can prevent accidental modification.

Cambridge tip. Mark scheme expects the precise distinction: variable = changeable, constant = fixed. Don't say 'constants are like variables but...'.

Cambridge tests these data types:

Type	Stores	Example
Integer	Whole numbers	-3, 0, 42
Real (Float)	Numbers with decimals	3.14, -0.5
Boolean	TRUE / FALSE	TRUE
String	Sequence of characters	"Hello"
Char	Single character	'A'
Date	Date / DateTime	09/05/2026

Choose the right type.

• Counter / age / quantity → integer.
• Price / measurement / scientific value → real.
• Yes/no / on/off / true/false → boolean.
• Names / addresses / messages → string.
• Single grade letter / single character flag → char (or string of length 1).
• Birthdays / timestamps → date / datetime.

Cambridge tip. Match the type to the SCENARIO. Using integer for prices loses pence; using string for ages prevents arithmetic.

A subroutine is a self-contained block of code that does a task. Two kinds:

Procedure. Does a task; does NOT return a value.

PROCEDURE DisplayMenu()
  OUTPUT "1. Add"
  OUTPUT "2. Remove"
  OUTPUT "3. Quit"
ENDPROCEDURE

Called: CALL DisplayMenu().

Function. Does a task; RETURNS a value to the caller.

FUNCTION AreaOfCircle(radius : REAL) RETURNS REAL
  RETURN 3.14159 * radius * radius
ENDFUNCTION

Called: area ← AreaOfCircle(5).

Both share:

• They take parameters (variables that receive values from the caller).
• They have local variables (private to the subroutine).
• They can be called from many places — write once, use many times.

Why use subroutines.

• Reuse — write once, call from many places.
• Less duplication — no copy-pasted code drifting out of sync.
• Easier to test — test each subroutine in isolation.
• Modular — top-level code reads as a sequence of named operations.

Cambridge tip. When asked to distinguish, the SINGLE rule is: function returns a value, procedure does not.

A variable's scope is the part of the program where it's accessible.

Local variables. Declared INSIDE a subroutine; only accessible within that subroutine. Created when the subroutine is called and destroyed when it ends.

Global variables. Declared OUTSIDE all subroutines; accessible EVERYWHERE in the program. Persists for the program's lifetime.

Why prefer local.

• Encapsulation — one subroutine can't accidentally change another's variables.
• Easier debugging — variable changes localised.
• Less memory — local variables are reclaimed when the subroutine ends.
• Reuse — subroutines work on parameters and locals; can be lifted between programs.

When global IS appropriate.

• Configuration values needed everywhere (often defined as CONSTANTS, not variables).
• A few clearly-named state variables shared across the whole program.

Cambridge tip. Mark scheme expects the distinction (where declared / where visible) AND a stated advantage of local (one of: encapsulation, debugging, memory, reuse).

Strings are sequences of characters; Cambridge has a small set of built-in functions for manipulating them.

LENGTH(text). Returns the number of characters.

LENGTH("Hello")  → 5

SUBSTRING(text, start, length). Returns a slice of the string.

SUBSTRING("Computer", 1, 4)  → "Comp"
SUBSTRING("Computer", 5, 4)  → "uter"

UCASE(text). Convert to uppercase.

UCASE("hello")  → "HELLO"

LCASE(text). Convert to lowercase.

LCASE("WORLD")  → "world"

Concatenation (+). Join strings together.

Greeting ← "Hello, " + Name

Cambridge tip. Use Cambridge pseudocode names (LENGTH, SUBSTRING, UCASE, LCASE) — not Python's len/slice or Java's .length(). Mark schemes deduct for language-specific syntax.