Data types

A data type tells the compiler two things: what values a variable may hold, and what operations are legal on it. AQA expects you to know these:

Why it matters: choosing integer over real where you can is not fussiness — integers are exact, while reals are stored in floating point and carry rounding error. Money is best held as an integer number of pence.

Constructs, DIV and MOD

Three constructs are enough to express any computable algorithm (this is the structure theorem): sequence, selection and iteration.

• Sequence — statements executed one after another.
• Selection — IF / ELSE IF / ELSE, or CASE/SWITCH.
• Iteration — definite (FOR: a known number of repeats) or indefinite (WHILE / REPEAT: repeats until a condition changes).

Two arithmetic operators that catch people out:

Classic use: MOD 2 = 0 tests for even. MOD also wraps a value round a circular buffer, and DIV/MOD together split a total of seconds into minutes and seconds.

Your turn — DIV and MOD

Integer vs real division

Subroutines and parameters

A subroutine is a named block of code that can be called from elsewhere. AQA distinguishes:

• a procedure — performs an action, returns no value;
• a function — returns exactly one value to the point of call.

Values passed in are parameters (in the definition) and arguments (at the call). There are two ways to pass them:

Watch out: in Python and Java, objects and lists are passed by object reference — mutating the list inside a function does change the caller's list, even though reassigning the name does not.

Parameter passing

Local and global scope

Scope is the region of a program in which an identifier is visible.

• A local variable is declared inside a subroutine. It is created when the subroutine is called and destroyed when it returns. It cannot be seen outside.
• A global variable is declared outside all subroutines and is visible everywhere for the whole run of the program.

Locals are preferred because they:

• prevent accidental side effects from unrelated code;
• let the same name be reused safely in different subroutines;
• free their memory on return, and make subroutines self-contained and reusable.

Shadowing: if a local has the same name as a global, the local wins inside that subroutine — the global is hidden, not overwritten.

Scope

Recursion

A subroutine is recursive if it calls itself. Every valid recursive routine needs:

• a base case (stopping condition) that returns without recursing;
• a general case that calls itself with arguments moving towards the base case;
• a guarantee the base case is always reached — otherwise you get infinite recursion and a stack overflow.

Each call pushes a stack frame onto the call stack holding the return address, the parameters and the locals. The frames unwind in reverse (last in, first out) as each call returns.

Trade-off: recursion is elegant for problems with a naturally recursive structure (tree traversal, quicksort, merge sort, Towers of Hanoi) but uses more memory than iteration and is slower because of the call overhead. Any recursive routine can be rewritten iteratively, using an explicit stack if necessary.

Your turn — trace the recursion

Your turn — counting the calls

Object-oriented programming — classes and encapsulation

A class is a blueprint: it defines the attributes (data) and methods (behaviour) that its instances will have. An object is an instance of a class, created by instantiation — the constructor runs and sets the initial state.

Encapsulation (information hiding) means attributes are declared private and can only be read or changed through public methods (getters and setters).

Because balance is private, no outside code can set it to a negative number: the class enforces its own invariants. The internal representation can also be changed later without breaking any code that uses the class.

Inheritance, polymorphism, abstraction

Inheritance: a subclass derives from a superclass, gaining its attributes and methods and adding or changing its own. It models an is-a relationship — a Savings account is a kind of Account.

Overriding: the subclass supplies its own version of an inherited method with the same signature.

Polymorphism: one interface, many forms. The same call on different objects runs different code, chosen at run time by the object's actual class.

Composition (has-a) is the alternative to inheritance: a Car has an Engine. The maxim "favour composition over inheritance" exists because deep inheritance hierarchies are brittle — a change high up breaks everything below.

Abstraction in OOP: the public interface tells you what an object does; the private implementation hides how. You can drive a car without knowing how the engine works.

Polymorphism

Encapsulation

Exception handling

An exception is a run-time error — a fault that only appears when the program actually runs (not a syntax error, which the translator catches first).

• Dividing by zero
• Converting "seven" to an integer
• Indexing past the end of an array
• Opening a file that does not exist

A try / except (catch) block lets the program recover instead of crashing:

Exam point: exception handling makes a program robust — it copes with invalid input and unexpected conditions gracefully rather than terminating. Do not use a bare catch-everything block that silently swallows errors: a bug you never see is worse than one that crashes.

Exceptions

Sort the terms

Tap a term, then tap the group it belongs to.

Match the definition to the term

Tap an item on the left, then its partner on the right.

The big ideas to know

That is the whole of AQA 4.1. Press Finish to see your score.