AQA A-Level Computer Science

Last Accessed

Recently visited lessons will appear here for quick access.Start exploring your first lesson today!

Shared theory

Theory of computation

4.4.1.3–4.4.1.8 - Abstraction and information hidingLearn how useful models retain essential detail, how interfaces hide implementation, and how a complicated problem can become a familiar solvable one.
4.4.2.1 - Finite-state machines and Mealy outputLearn to follow a machine's state, convert between diagrams and tables, and read the transition output of a Mealy machine.
4.4.2.2 - Sets, countability and Cartesian productsLearn to describe collections precisely, distinguish kinds of infinity, and use subsets, ordered products and set operations.
4.4.3.1 - BNF and syntax diagramsLearn to read and write grammar rules, check strings against syntax diagrams, and explain the extra power supplied by recursive BNF rules.
4.4.4.4–4.4.4.7 - Tractability and limits of computationLearn to distinguish resource limits from impossible algorithmic tasks, and explain what the Halting problem means for computing.

Data representation

4.5.1.1–4.5.1.7 - Number systems, counting and measurementIn 4.5.1.1–4.5.1.5 you will distinguish the sets used to describe numbers. In 4.5.1.6–4.5.1.7 you will use numbers for position, counting and measurement. These distinctions help you decide what a stored value means before choosing how to represent it.
4.5.2.1, 4.5.3.1–4.5.3.2 - Number bases and units of informationIn 4.5.2.1 you will read and convert decimal, binary and hexadecimal values. In 4.5.3.1–4.5.3.2 you will connect bits to possible values and convert byte quantities using precise decimal and binary prefixes.
4.5.4.1–4.5.4.2 - Unsigned binary arithmeticIn 4.5.4.1 you will interpret unsigned values and their limits. In 4.5.4.2 you will add and multiply binary integers, checking whether the result fits the available bits.
4.5.4.3 - Signed binary and two's complementYou will encode and decode positive and negative integers using two's complement, calculate its range, and use addition to perform subtraction. The interpretation of the most-significant bit is what makes a negative value possible.
4.5.4.4 - Fixed-point and floating-point representationYou will encode and decode binary values with fractional parts using fixed point and a simplified mantissa-and-exponent format. The format must state the bit allocation and binary-point position before any pattern has a definite value.
4.5.4.5–4.5.4.6 - Rounding, absolute and relative errorsYou will explain why finite binary representations can approximate decimal values, choose a value by truncation or rounding, and calculate absolute and relative error. The size of an error matters in relation to the quantity being stored.
4.5.4.7–4.5.4.9 - Floating-point range, normalisation and limitsYou will compare range, precision and calculation demands in fixed and floating point, normalise positive and negative mantissas, and diagnose underflow and overflow. Use the stated format: bit allocation and normalisation rules determine the limits.
4.5.5.1–4.5.5.2 - Character digits, ASCII and UnicodeLearn how a computer distinguishes a number from the characters used to write it, and how character coding systems let different computers exchange readable text.
4.5.5.3 - Error checking and correctionLearn how redundant information makes some data errors detectable, when an error can be corrected, and why passing a check does not guarantee that data is correct.
4.5.6.1–4.5.6.3 - Bit patterns and analogue-to-digital conversionLearn how the same bits can represent different kinds of data, and how converters connect continuously varying physical measurements with discrete digital values.
4.5.6.4–4.5.6.6 - Bitmapped and vector graphicsLearn how images are represented as pixels or geometric objects, calculate bitmap storage, and choose a representation that fits the image and its intended use.
4.5.6.7–4.5.6.8 - Digital sound and MIDILearn how sound becomes a sequence of digital amplitude samples, how recording settings affect storage and fidelity, and why MIDI stores a musical performance differently.
4.5.6.9 - Lossless and lossy compressionLearn why files are compressed, distinguish lossless from lossy methods, and encode and decode simple run-length and dictionary representations while accounting for their overheads.

Computer systems

4.6.1.1–4.6.1.3 - Hardware, software and system toolsA useful computer needs physical components and instructions that make them work together. Learn how applications depend on system software, and why an operating system, utilities, libraries and translators have different jobs.
4.6.1.4 - Operating-system responsibilitiesAn operating system makes complex hardware usable and shares limited resources between programs. Follow what happens when applications compete for processor time, memory and input/output devices.
4.6.2.1 - High-level and low-level languagesProgramming languages differ in how closely they expose the processor's instructions. Compare machine code, assembly and imperative high-level languages, then justify a choice for a particular task.
4.6.3.1 - Compilers, interpreters and assemblyA processor cannot directly execute arbitrary source text. Learn how assemblers, compilers and interpreters bridge that gap, and why some systems translate through bytecode rather than directly to a target machine.
4.6.4.1 - Logic gates and truth tablesLogic circuits turn binary inputs into decisions, arithmetic and stored state. Learn to interpret standard gate symbols, construct truth tables and expressions, follow half- and full-adders, and explain how an edge-triggered D-type flip-flop stores one bit.
4.6.5.1 - Boolean algebra and simplificationDifferent Boolean expressions can implement the same decision. Learn to use identities and De Morgan's laws to simplify an expression, preserving its meaning and checking every input combination.

Computer organisation and architecture

4.7.1.1, 4.7.2.1 - Internal hardware and the stored-program conceptA computer executes instructions by moving information between connected components. In 4.7.1.1 you will explain those components, addressable memory and two ways of organising instruction and data storage. In 4.7.2.1 you will see why storing instructions in memory lets the same hardware run diff...
4.7.3.1–4.7.3.2 - Processor registers and the fetch-execute cycleInstructions become actions through a sequence of small transfers inside the processor. In 4.7.3.1 you will distinguish its components and registers; in 4.7.3.2 you will trace how they fetch, decode and execute a stored instruction.
4.7.3.3–4.7.3.4 - Instruction sets and addressing modesA processor must interpret both what an instruction requests and where its data comes from. In 4.7.3.3 you will read a simple processor-specific instruction format; in 4.7.3.4 you will distinguish and apply immediate and direct addressing.
4.7.3.6–4.7.3.7 - Interrupts and processor performanceA processor must respond to events while preserving the program it interrupted, and its speed depends on more than clock frequency. In 4.7.3.6 you will follow interrupt handling; in 4.7.3.7 you will explain how six hardware factors affect performance under different workloads.
4.7.4.1 - Input and output devicesAn input device converts something in the world into data a computer can use; an output device presents processed data in a useful form. In 4.7.4.1 you will explain the operation, characteristics and suitability of barcode readers, digital cameras, laser printers and RFID systems.
4.7.4.2 - Secondary storage technologiesFiles need storage that retains them after power is removed, and different technologies meet different access and capacity requirements. In 4.7.4.2 you will explain magnetic, optical and solid-state storage, including NAND pages and blocks, then compare their suitability for real tasks.

Communication and networking

4.9.1.1–4.9.1.2 - Transmission, bit rate and bandwidthLearn how devices move bits, agree their timing and measure a connection. Distinguish the rate of signals from the rate of useful data, and explain why a fast link can still feel slow.
4.9.2.1–4.9.2.2 - Network topology and peer-to-peer or client-server modelsSeparate a network's physical connections from the way its data travels. Then compare equal peers with clients requesting centrally managed services, using the requirements of a real organisation.
4.9.2.3 - WiFi, access control and collision avoidanceLearn how a device joins a wireless local network, what its security measures protect, and how shared-channel access reduces collisions. Follow both ordinary CSMA/CA and the optional RTS/CTS exchange.
4.9.3.1 - The Internet, packets, routing and DNSFollow data across interconnected networks, distinguish routing from name lookup, and explain how distributed naming and address administration make the Internet usable at scale.
4.9.3.2 - Firewalls, cryptography and malicious softwareExplain how network controls, encryption and identity checks protect different things. Distinguish malware mechanisms and connect each defence to the vulnerability it addresses.
4.9.4.1 - TCP and IP layers, sockets and portsFollow a message down the four TCP/IP layers and back up at its destination. Distinguish local hardware addresses from end-to-end addresses and explain how ports direct data to the right application.
4.9.4.2 - Web, mail, file-transfer and SSH protocolsLearn how application protocols give meaning to network messages, and how clients and servers use them to transfer files, deliver email, display web pages and manage remote computers.
4.9.4.3–4.9.4.6 - IP addresses, subnets and IPv6Learn how an IP address identifies a network and a host, how subnet masks separate those parts, why IPv6 was introduced and which addresses can be routed on the public Internet.
4.9.4.7–4.9.4.9 - DHCP, NAT and port forwardingLearn how DHCP configures a host, how NAT lets private hosts communicate using public addresses, and how port forwarding directs an incoming connection to a chosen internal service.
4.9.4.10 - Client-server web applications, REST and data formatsLearn how browser applications exchange messages with servers, how REST connects web requests to stored data, how WebSockets support live updates, and how JSON and XML represent exchanged data.
4.9.4.11 - Thin-client and thick-client computingLearn how the location of processing and storage distinguishes thin and thick clients, and how network dependence, management and workload affect the choice between them.

Databases

4.10.1–4.10.2 - Relational data models, keys and entity relationshipsLearn to turn a set of data requirements into related entities, choose keys and describe relationships. A good model records each kind of fact in a suitable place and makes the links between records unambiguous.
4.10.3 - Database normalisation to third normal formLearn why repeated facts cause database anomalies and how functional dependencies guide normalisation. Work from repeating groups to first normal form, remove partial dependencies for second normal form, then remove transitive dependencies for third normal form.
4.10.5 - Concurrent database access and integrityLearn why a client–server database needs concurrency controls when several clients use the same records. Trace a lost update, then distinguish record locks, serialisation, timestamp ordering and commitment ordering.

Independent project skills

4.14.1.1–4.14.1.3, 4.14.4 - Independent projects, suitable problems and evidenceLearn how to choose and scope a realistic independent project, tackle its main technical risk and organise concise evidence. These examples practise project skills; they do not supply or certify a student's assessed NEA.
4.14.3.1, 4.14.5.1 - Project analysis and measurable objectivesLearn how to investigate a problem, define its scope and turn user needs into measurable objectives and a useful model. All examples are independent formative practice rather than assessed NEA submissions.
4.14.3.2, 4.14.5.2 - Documented project designLearn to communicate the structure, important decisions and dependencies of a solution clearly enough for a third party to understand. These design examples are formative practice, not a design for your assessed NEA.
4.14.2.1–4.14.2.2, 4.14.3.5–4.14.3.6, 4.14.5.4–4.14.5.5, 4.14.6 - Project testing, evaluation and evidence qualityLearn to select and explain testing evidence, evaluate outcomes and interpret the formal NEA evidence framework. The examples use original formative rubrics and do not authenticate or award marks to a student's assessed project.
6.1–6.2 - Authenticity, attribution and responsible assistanceLearn how independent work, transparent attribution and appropriate support protect the authenticity of a project. This lesson follows AQA's July 2026 NEA AI guidance and teaches formative skills; NovaLearn does not complete or certify assessed NEA.

Python route

Programming

4.1.1.1 - Data types and references (Python)Choose suitable types for a program's values, follow references to objects, and build records and indexed collections in Python.
4.1.1.2, 4.1.1.3, 4.1.1.6 - Variables, constants and arithmetic (Python)Follow assignments in sequence, use meaningful names and constants, and choose arithmetic operations that match the required result.
4.1.1.2, 4.1.1.4, 4.1.1.5 - Selection and Boolean conditions (Python)Build precise comparisons, combine Boolean conditions, and choose the correct branch of a Python program, including boundary and nested cases.
4.1.1.2 - Definite, indefinite and nested iteration (Python)Choose a suitable loop, trace its changing state, and combine loops with selection, including pre-test, post-test and nested repetition.
4.1.1.7 - Strings, character codes and dates (Python)Extract and combine text, convert between characters and their codes, and convert numerical and date/time values without losing their meaning.
4.1.1.8 - Random numbers and controlled simulations (Python)Generate values from the intended range, build a small random simulation, and test its rules without assuming every run produces the same result.
4.1.1.9 - Exceptions and defensive input (Python)Distinguish exceptions from ordinary invalid data, handle specific failures in Python, and recover without accidentally using an unsuccessful result.
4.1.1.10–4.1.1.12 - Subroutines, parameters and return values (Python)Learn how named subroutines divide a program into understandable tasks, how parameters form an interface, and how a returned value lets the caller continue its work.
4.1.1.13–4.1.1.14 - Local and global variable scope (Python)Learn which variables a subroutine can access, how long its local variables last, and how parameters and return values make changes to state easier to understand.
4.1.1.15–4.1.1.16 - Stack frames and recursion (Python)Learn how pending subroutine calls retain their own state, how a recursive call reaches a base case, and how to trace the results as calls return.
4.1.2.1–4.1.2.2 - Procedural design and hierarchy charts (Python)Learn how to decompose a program into cooperating modules, represent that design with a hierarchy chart, and construct a procedural solution with clear interfaces.
4.1.2.3 - Classes, objects and encapsulation (Python)Learn how classes define state and behaviour, how objects are created and referenced, and how controlled access and different kinds of methods support an object-oriented design.
4.1.2.3 - Inheritance, polymorphism and object relationships (Python)Learn how specialised classes reuse and override behaviour, how a common operation selects different implementations, and how ownership and interfaces guide class relationships.

Data structures

4.2.1.1–4.2.1.2 - Data structures and multidimensional arrays (Python)Choose structures that match a problem, represent vectors and matrices with indexed collections, and write Python solutions that visit each required element safely.
4.2.1.3 - Text and binary files (Python)Read and write persistent text and binary data in Python, agree a record format, and test that files retain the values the program intends to store.
4.2.1.4, 4.2.2.1 - Abstract data types and queues (Python)Separate an abstract structure's operations from its implementation, compare static and dynamic storage, and maintain linear, circular and priority queues without losing items at their boundaries.
4.2.3.1 - Stacks and their operations (Python)Use last-in, first-out storage, trace stack state, and implement push, pop and peek with correct empty and full checks in Python.
4.2.4.1 - Graphs and adjacency representations (Python)Model relationships as graphs, construct adjacency matrices and lists in Python, and choose a representation for the operations and graph size a problem needs.
4.2.5.1 - Trees, rooted trees and binary trees (Python)Distinguish trees from general graphs, describe rooted and binary relationships, and represent tree nodes through Python references without assuming every binary tree is a search tree.
4.2.6.1, 4.2.7.1 - Hash tables and dictionaries (Python)Use keys to retrieve values, apply a simple hash function and rehashing rule, and build Python dictionaries for practical information retrieval.
4.2.8.1 - Vectors, translation and dot products (Python)Represent vectors as indexed values and functions, connect their operations to geometry, and implement vector combinations and dot products in Python.

Algorithms

4.3.1.1 - Breadth-first and depth-first graph traversal (Python)Learn how queues and stacks control the order in which a graph is explored, how to trace the changing state, and why the two traversals suit different problems.
4.3.2.1 - Tree traversals (Python)Learn to trace pre-order, in-order and post-order traversals, explain where each places the root, and choose an order for copying, sorting output or processing an expression tree.
4.3.3.1 - Reverse Polish and infix expressions (Python)Learn to convert between infix and Reverse Polish notation, evaluate expressions with a stack, and preserve operand order when implementing the evaluation in Python.
4.3.4.1–4.3.4.3 - Linear, binary and binary-tree search (Python)Learn to trace three search algorithms, implement their key boundary decisions, and explain how ordering and tree balance affect their time complexity.
4.3.5.1–4.3.5.2 - Bubble sort and merge sort (Python)Learn to trace bubble passes and merge stages, implement their local operations, and explain why divide-and-conquer improves the growth of sorting time.
4.3.6.1 - Dijkstra's shortest-path algorithm (Python)Learn to apply a supplied shortest-path algorithm, trace tentative distances and predecessor changes, and interpret the route found in a weighted graph.

Theory of computation

4.4.1.1–4.4.1.2 - Solving problems and tracing algorithms (Python)Turn a precise problem into a terminating algorithm, trace its state and translate it into Python. Learn how reasoning, test data and user feedback provide different kinds of evidence that a solution is suitable.
4.4.1.9–4.4.1.11 - Decomposition, composition and automation (Python)Break a problem into identifiable tasks, combine procedures and data into useful abstractions, then put a model into action. Use a small stock-control system to see how these choices become executable Python.
4.4.2.3–4.4.2.4 - Regular expressions and regular languages (Python)Describe sets of strings using regular expressions and connect them with finite-state machines. Construct simple patterns, check whole strings and apply the same ideas to Python matching and replacement.
4.4.4.1–4.4.4.3 - Functions, growth and algorithm complexity (Python)Use functions to describe how work grows with input size. Compare time and memory, calculate permutations and derive Big-O from an algorithm's actual operations rather than from the presence of a loop alone.
4.4.5.1 - Turing machines as a model of computation (Python)Read a Turing machine's tape and transition rules, trace a simple computation and implement one transition in Python. Connect this formal model with universal computation while keeping its mathematical rules distinct from the simulator.

Functional programming

4.12.1.1–4.12.1.3 - Function types, first-class values and application (Python)Learn how a function maps inputs to outputs, why functions can themselves be values, and how applying a function differs from referring to it. Use Python to explore the ideas, then express them in the functional notation used in Paper 2.
4.12.1.4–4.12.1.5 - Partial application and function composition (Python)Read curried function types, work out what remains after partial application, and combine functions in the correct order. Explore returned functions in Python while keeping the functional notation needed for written Paper 2 responses.
4.12.2.1 - Higher-order functions, map, filter and fold (Python)Build simple functional transformations using functions as arguments and results. Learn how map changes every element, filter selects elements, and a seeded fold combines them into one result without changing the source list.
4.12.3.1 - Functional lists, heads, tails and construction (Python)Represent a list as its first element and remaining list, handle the empty case, and construct new lists by prepending or appending. Use these operations to build functional Python programs that preserve their inputs.

C# route

Programming

4.1.1.1 - Data types and references (C#)A program needs to know what a value means before it can store or process it. Learn how C# types describe values, how references connect variables to objects, and how arrays and user-defined records organise related data.
4.1.1.2, 4.1.1.3, 4.1.1.6 - Variables, constants and arithmetic (C#)Use declarations, assignments and sequence to keep track of a program's state (4.1.1.2). Learn the arithmetic operations in 4.1.1.3, then use named constants to express fixed decisions clearly (4.1.1.6).
4.1.1.2, 4.1.1.4, 4.1.1.5 - Selection and Boolean conditions (C#)Selection chooses which statements a program performs (4.1.1.2). Build decisions from relational comparisons (4.1.1.4) and Boolean operators (4.1.1.5), then trace nested decisions and test their boundaries.
4.1.1.2 - Definite, indefinite and nested iteration (C#)Iteration repeats a useful sequence of statements. Learn when to use count-controlled, pre-test and post-test loops, then track the state of nested loops without losing the purpose of each counter.
4.1.1.7 - Strings, character codes and dates (C#)Text often arrives as a single string even when a program needs separate fields, numbers or dates. Learn to locate and extract text, convert character codes, and make numeric and date conversions with explicit formats.
4.1.1.8 - Random numbers and controlled simulations (C#)Random values let a program model chance without asking a user for every outcome. Learn the exact limits of C# random-number methods, then separate unpredictable sampling from deterministic checks of a simulation's logic.
4.1.1.9 - Exceptions and defensive input (C#)Input and external operations can fail even when a program's intended algorithm is sound. Learn what an exception does to control flow, how specific handlers report failure, and how validation and recovery keep a program in a safe state.
4.1.1.10–4.1.1.12 - Subroutines, parameters and return values (C#)Learn how named subroutines divide a program into reusable operations, pass data through a clear interface and return results to their caller.
4.1.1.13–4.1.1.14 - Local and global variable scope (C#)Learn where variables can be accessed, how long a subroutine's local state lasts, and why explicit parameters and return values usually make dependencies easier to control.
4.1.1.15–4.1.1.16 - Stack frames and recursion (C#)Learn how a call stack preserves each subroutine's state, and how a recursive solution reaches a base case before returning through its waiting calls.
4.1.2.1–4.1.2.2 - Procedural design and hierarchy charts (C#)Learn how procedural and object-oriented programs organise responsibilities, and how structured decomposition and hierarchy charts turn a problem into testable modules.
4.1.2.3 - Classes, objects and encapsulation (C#)Learn how classes define state and behaviour, constructors initialise separate objects, and controlled access protects an object's valid state.
4.1.2.3 - Inheritance, polymorphism and object relationships (C#)Learn how derived classes vary inherited behaviour, how polymorphism selects that behaviour, and how UML distinguishes inheritance from whole-part object relationships.

Data structures

4.2.1.1–4.2.1.2 - Data structures and multidimensional arrays (C#)Choose a structure that fits a problem, represent vectors and matrices with arrays, and use indexes to process their elements in C#. This route is incomplete: runnable support pending; its code examples and questions are written practice with no Run.
4.2.1.3 - Text and binary files (C#)Read and write persistent data using text and binary files, then choose tests that detect format and boundary errors. This C# route is incomplete: runnable support pending; all source responses here are written practice with no Run.
4.2.1.4, 4.2.2.1 - Abstract data types and queues (C#)Separate a structure's behaviour from its implementation, then create and maintain linear, circular and priority queues in C#. This route is incomplete: runnable support pending; code questions are written practice with no Run.
4.2.3.1 - Stacks and their operations (C#)Model last-in, first-out storage, apply push, pop and peek, and protect a bounded C# stack from invalid operations. This route is incomplete: runnable support pending; code tasks are written practice with no Run.
4.2.4.1 - Graphs and adjacency representations (C#)Represent relationships as graphs, convert between adjacency matrices and lists, and choose a representation for a C# solution. This route is incomplete: runnable support pending; source questions are written practice with no Run.
4.2.5.1 - Trees, rooted trees and binary trees (C#)Distinguish a tree from a general graph, interpret rooted relationships, and represent a binary tree using C# nodes. This route is incomplete: runnable support pending; code tasks are written practice with no Run.
4.2.6.1, 4.2.7.1 - Hash tables and dictionaries (C#)Map keys to values, apply simple hash functions and collision handling, and use a C# dictionary for information retrieval. This route is incomplete: runnable support pending; source questions are written practice with no Run.
4.2.8.1 - Vectors, translation and dot products (C#)Represent vectors as lists, arrays and functions, use them for translation and scaling, and calculate dot products and angles. This C# route is incomplete: runnable support pending; code questions are written practice with no Run.

Algorithms

4.3.1.1 - Breadth-first and depth-first graph traversal (C#)Learn how a queue or stack controls the order in which a graph is explored, trace both traversals and choose one for an appropriate application.
4.3.2.1 - Tree traversals (C#)Learn to trace pre-order, in-order and post-order visits through a binary tree, and connect each order to a useful operation.
4.3.3.1 - Reverse Polish and infix expressions (C#)Learn to convert between infix and Reverse Polish notation, evaluate RPN with a stack and preserve operand order in native C# code.
4.3.4.1–4.3.4.3 - Linear, binary and binary-tree search (C#)Learn to trace three search algorithms, implement their decisions in C# and explain how ordering and tree height affect search time.
4.3.5.1–4.3.5.2 - Bubble sort and merge sort (C#)Learn to trace bubble passes and recursive merges, write bounded C# sorting logic and explain their different growth rates.
4.3.6.1 - Dijkstra's shortest-path algorithm (C#)Learn to apply a supplied shortest-path algorithm, update tentative distances and reconstruct a least-weight route from predecessor records.

Theory of computation

4.4.1.1–4.4.1.2 - Solving problems and tracing algorithms (C#)Develop a precise solution, express it in pseudocode, translate it into C# and check the reasoning behind its results. This route uses written C# tasks and is incomplete: runnable support pending; Paper 1 itself is an onscreen practical examination.
4.4.1.9–4.4.1.11 - Decomposition, composition and automation (C#)Break a problem into identifiable tasks, combine procedures and data, then put an abstract model into action through an algorithm. This route uses written C# tasks and is incomplete: runnable support pending.
4.4.2.3–4.4.2.4 - Regular expressions and regular languages (C#)Describe sets of strings using regular expressions, relate them to finite-state machines and apply simple patterns in C#. This route uses written C# tasks and is incomplete: runnable support pending.
4.4.4.1–4.4.4.3 - Functions, growth and algorithm complexity (C#)Use mathematical functions to compare growth, count permutations and derive the time and space demands of C# algorithms. This route uses written C# tasks and is incomplete: runnable support pending.
4.4.5.1 - Turing machines as a model of computation (C#)Represent and trace a simple Turing machine, relate its rules to a C# simulator and explain what the model contributes to computation. This route uses written C# tasks and is incomplete: runnable support pending.

Functional programming

4.12.1.1–4.12.1.3 - Function types, first-class values and application (C#)Learn how function types describe permitted inputs and results, how a function can be stored and passed as a value, and how application supplies its arguments.
4.12.1.4–4.12.1.5 - Partial application and function composition (C#)Learn how supplying some arguments can produce a specialised function, and how composition builds a new function by applying two functions in a specified order.
4.12.2.1 - Higher-order functions, map, filter and fold (C#)Learn how higher-order functions express list transformations, then use C# function values to map, filter and fold data into a result.
4.12.3.1 - Functional lists, heads, tails and construction (C#)Learn how a list is built from a head and tail, how to handle its empty case, and how C# functions can construct and process new lists while preserving their inputs.

Java route

Programming

4.1.1.1 - Data types and references (Java)Choose suitable Java types, distinguish values from references, and group related data into arrays and your own structured types.
4.1.1.2, 4.1.1.3, 4.1.1.6 - Variables, constants and arithmetic (Java)Track declaration and assignment in sequence, use named constants, and choose the right Java operation for division, powers, rounding and truncation.
4.1.1.2, 4.1.1.4, 4.1.1.5 - Selection and Boolean conditions (Java)Build precise comparisons and combined conditions, then choose and nest Java branches without losing boundary cases.
4.1.1.2 - Definite, indefinite and nested iteration (Java)Choose count-controlled, pre-test and post-test Java loops, then trace how nested loops change state and terminate.
4.1.1.7 - Strings, character codes and dates (Java)Select and join string content, convert characters and numbers, and parse or format Java date/time values with explicit formats.
4.1.1.8 - Random numbers and controlled simulations (Java)Generate values within precise Java ranges and design simulations whose random behaviour can be checked without guessing one output.
4.1.1.9 - Exceptions and defensive input (Java)Recognise Java exceptions, handle a specific failure, and combine conversion checks with validation so input can recover safely.
4.1.1.10–4.1.1.12 - Subroutines, parameters and return values (Java)Learn how named methods split a Java program into manageable jobs, how arguments supply their inputs and how a returned value supplies a result. These ideas let one calculation serve many callers without copying its source. This Java route is incomplete: runnable support pending; the examples and...
4.1.1.13–4.1.1.14 - Local and global variable scope (Java)Learn where a Java variable can be used, how each method call gets its own local state, and how shared state can make changes harder to reason about. Choose local variables and explicit parameters when a task does not need shared state. This Java route is incomplete: runnable support pending; sou...
4.1.1.15–4.1.1.16 - Stack frames and recursion (Java)Learn how the call stack preserves unfinished method calls and how a recursive solution combines a stopping case with a smaller problem. Trace both the calls and the returning results before writing recursive Java methods. This Java route is incomplete: runnable support pending; source tasks are...
4.1.2.1–4.1.2.2 - Procedural design and hierarchy charts (Java)Learn how to break a program into cooperating jobs, describe their interfaces and use a hierarchy chart to organise a design. Compare organising work around procedures with organising it around objects. This Java route is incomplete: runnable support pending; the source and design tasks are writt...
4.1.2.3 - Classes, objects and encapsulation (Java)Learn how a Java class defines object state and behaviour, how constructors create usable instances, and how access controls protect that state. Distinguish instance methods from static and abstract methods before the next lesson develops relationships between classes. This Java route is incomple...
4.1.2.3 - Inheritance, polymorphism and object relationships (Java)Learn how Java subclasses inherit and override behaviour, how a common reference type supports polymorphism, and when a “has a” relationship is a better design. Interpret UML relationship symbols and apply the three specified object-oriented design principles. This Java route is incomplete: runna...

Data structures

4.2.1.1–4.2.1.2 - Data structures and multidimensional arrays (Java)Choose structures that fit a problem, represent vectors and matrices with arrays, and design Java methods that process indexed data correctly.
4.2.1.3 - Text and binary files (Java)Read and write structured text and binary data in Java, and use a stated file format to decide how values should be interpreted and tested.
4.2.1.4, 4.2.2.1 - Abstract data types and queues (Java)Separate a structure's operations from its implementation, compare fixed and growing storage, and maintain linear, circular and priority queues in Java.
4.2.3.1 - Stacks and their operations (Java)Use last-in, first-out state to design and trace push, pop, peek, empty and full operations in Java.
4.2.4.1 - Graphs and adjacency representations (Java)Model relationships with graphs and implement adjacency matrices and lists in Java, choosing a representation suited to the operations and density of the graph.
4.2.5.1 - Trees, rooted trees and binary trees (Java)Distinguish trees from general graphs, use a root to define parent-child relationships, and represent binary-tree nodes with Java references.
4.2.6.1, 4.2.7.1 - Hash tables and dictionaries (Java)Map keys to values, apply a simple hash, resolve collisions with a stated rehashing rule, and use Java dictionaries for information retrieval.
4.2.8.1 - Vectors, translation and dot products (Java)Represent vectors as lists, arrays and functions, calculate translation, scaling and convex combinations, and use a dot product to find an angle.

Algorithms

4.3.1.1 - Breadth-first and depth-first graph traversal (Java)Learn how breadth-first and depth-first search visit a graph, trace their changing state and choose between them for an unweighted route or a maze. Java examples and code answers are written practice. This route is incomplete: runnable support pending.
4.3.2.1 - Tree traversals (Java)Trace pre-order, in-order and post-order traversal, then connect their visit positions to copying, ordered output and expression processing. Java source answers are written practice. This route is incomplete: runnable support pending.
4.3.3.1 - Reverse Polish and infix expressions (Java)Convert simple expressions between infix and Reverse Polish notation, evaluate a postfix expression with a stack and explain its use in interpreters. Java source answers are written practice. This route is incomplete: runnable support pending.
4.3.4.1–4.3.4.3 - Linear, binary and binary-tree search (Java)Trace linear search, binary search on a sorted array and search through a binary search tree. Relate each method's work to input size and tree height. Java source answers are written practice. This route is incomplete: runnable support pending.
4.3.5.1–4.3.5.2 - Bubble sort and merge sort (Java)Trace bubble-sort passes and merge-sort splitting/merging, explain their different growth rates and reason about Java implementations. Source answers are written practice. This route is incomplete: runnable support pending.
4.3.6.1 - Dijkstra's shortest-path algorithm (Java)Apply a supplied shortest-path algorithm to a weighted graph, trace tentative distances and recover a route from predecessors. AQA does not require recall of Dijkstra's steps. Java amendments are written practice. This route is incomplete: runnable support pending.

Theory of computation

4.4.1.1–4.4.1.2 - Solving problems and tracing algorithms (Java)Turn a precise problem into a terminating algorithm, trace its state changes and translate it into Java. Then use reasoning, tests and user feedback to check that the solution meets the original need. This Java route is incomplete: runnable support pending; its source questions are written practice.
4.4.1.9–4.4.1.11 - Decomposition, composition and automation (Java)Break a problem into identifiable tasks, combine procedures and data into useful abstractions, and see how an implemented model can automate a real task. This Java route is incomplete: runnable support pending; source work is written practice.
4.4.2.3–4.4.2.4 - Regular expressions and regular languages (Java)Describe sets of strings using regular expressions, connect simple expressions to finite-state machines and apply matching and replacement in Java. The formal language is the set of strings, rather than the programming language used to check it. This Java route is incomplete: runnable support pen...
4.4.4.1–4.4.4.3 - Functions, growth and algorithm complexity (Java)Use functions to express how an algorithm's work and storage change with problem size. Compare growth rates, count permutations and derive Big-O from Java source. This Java route is incomplete: runnable support pending; code questions are written practice.
4.4.5.1 - Turing machines as a model of computation (Java)Represent a simple Turing machine with transition rules and a state diagram, hand-trace its computation and examine a Java simulation. Explain why the model and a Universal Turing machine matter to computability. This Java route is incomplete: runnable support pending; source work has no Run.

Functional programming

4.12.1.1–4.12.1.3 - Function types, first-class values and application (Java)Describe a function's permitted inputs and outputs, treat functions as values, and distinguish a function from applying it. The mathematical notation describes the functional idea; Java examples show how this route represents it.
4.12.1.4–4.12.1.5 - Partial application and function composition (Java)Use one-, two- and three-argument function types to recognise when an application returns a value or another function. Then build new functions by partial application and composition, preserving the order and types in the functional notation.
4.12.2.1 - Higher-order functions, map, filter and fold (Java)Construct simple functional programs by passing functions to other functions. Use map, filter and fold to transform collections and combine results, tracing the values between stages rather than replacing functional operations with loops.
4.12.3.1 - Functional lists, heads, tails and construction (Java)Represent a functional list as a head followed by a tail, apply each required list operation, and construct results without changing the original list. Use these operations in a small recursive Java program.

VB.NET route

Programming

4.1.1.1 - Data types and references (VB.NET)Learn how a type determines the values and operations a program can use, then represent related data and distinguish copying a value from sharing an object. This route uses native written code and is incomplete: runnable support pending.
4.1.1.2, 4.1.1.3, 4.1.1.6 - Variables, constants and arithmetic (VB.NET)Learn to track values through a sequence of statements, use named constants and choose arithmetic that matches the required result. VB.NET questions in this route use written source; the route is incomplete: runnable support pending.
4.1.1.2, 4.1.1.4, 4.1.1.5 - Selection and Boolean conditions (VB.NET)Learn to turn requirements into comparisons and Boolean expressions, then select the right path with correct boundary behaviour. This is native written-code learning; the route is incomplete: runnable support pending.
4.1.1.2 - Definite, indefinite and nested iteration (VB.NET)Learn to choose a repetition structure, follow changes to loop state and combine loops with selection without losing track of boundaries. Native VB.NET tasks are written only; this route is incomplete: runnable support pending.
4.1.1.7 - Strings, character codes and dates (VB.NET)Learn to locate and extract text, convert between characters and their codes, and convert numeric and date values without confusing stored data with its display. VB.NET work is written only; this route is incomplete: runnable support pending.
4.1.1.8 - Random numbers and controlled simulations (VB.NET)Learn to generate values in the intended range, trace random-dependent logic with supplied draws and test simulations without expecting one fixed result. This VB.NET route is written only and incomplete: runnable support pending.
4.1.1.9 - Exceptions and defensive input (VB.NET)Learn how exceptions change control flow, handle expected failures precisely and validate input so a program can recover without using invalid data. This native written-code route is incomplete: runnable support pending.
4.1.1.10–4.1.1.12 - Subroutines, parameters and return values (VB.NET)Learn to split a program into named routines, pass data through precise interfaces and return results. The examples and marked source answers use VB.NET. This route is incomplete: runnable support pending; these are written code activities without Run, while the real Paper 1 is an onscreen practi...
4.1.1.13–4.1.1.14 - Local and global variable scope (VB.NET)Learn where a variable can be accessed, how long ordinary local state exists and why explicit parameters make routines easier to reason about. VB.NET source activities are written-only: this route is incomplete: runnable support pending.
4.1.1.15–4.1.1.16 - Stack frames and recursion (VB.NET)Learn how a call preserves its own state, how recursive calls reach a base case and how their results return in reverse order. VB.NET tasks assess written source and traces; this route is incomplete: runnable support pending.
4.1.2.1–4.1.2.2 - Procedural design and hierarchy charts (VB.NET)Learn to organise a program around routines, refine a large job into smaller modules and use a hierarchy chart to communicate that design. Compare this with organising behaviour around objects. The VB.NET route is incomplete: runnable support pending; marked programming here uses written source w...
4.1.2.3 - Classes, objects and encapsulation (VB.NET)Learn to define classes, create distinct objects and protect their state through controlled methods. Distinguish instance, shared, virtual and abstract methods in VB.NET. This route is incomplete: runnable support pending; source tasks have no Run. Inheritance and object relationships are develop...
4.1.2.3 - Inheritance, polymorphism and object relationships (VB.NET)Learn to specialise classes, dispatch overridden methods through a common type and distinguish ownership from inheritance. Interpret UML relationships and apply three object-oriented design principles. The VB.NET route is incomplete: runnable support pending; these are native written source tasks...

Data structures

4.2.1.1–4.2.1.2 - Data structures and multidimensional arrays (VB.NET)Choose structures that organise related data, represent vectors and matrices with arrays, and write indexed VB.NET solutions. This route uses written code with no Run: incomplete: runnable support pending.
4.2.1.3 - Text and binary files (VB.NET)Read and write text and binary data, keep file formats consistent, and test file-processing boundaries in VB.NET. This route uses written code with no Run: incomplete: runnable support pending.
4.2.1.4, 4.2.2.1 - Abstract data types and queues (VB.NET)Distinguish an abstract data type from its implementation, compare static and dynamic storage, and maintain linear, circular and priority queues. This VB.NET route uses written code with no Run: incomplete: runnable support pending.
4.2.3.1 - Stacks and their operations (VB.NET)Maintain a stack in VB.NET, distinguish push, pop and peek, and protect empty and full boundaries. This route uses written code with no Run: incomplete: runnable support pending.
4.2.4.1 - Graphs and adjacency representations (VB.NET)Model relationships as graphs, store their edges in matrices and lists, and choose a representation for a VB.NET solution. This route uses written code with no Run: incomplete: runnable support pending.
4.2.5.1 - Trees, rooted trees and binary trees (VB.NET)Recognise trees, describe rooted relationships, and represent binary nodes in VB.NET. This route uses written code with no Run: incomplete: runnable support pending.
4.2.6.1, 4.2.7.1 - Hash tables and dictionaries (VB.NET)Map keys to values, apply a simple hash with collision handling, and use VB.NET dictionaries for retrieval and counting. This route uses written code with no Run: incomplete: runnable support pending.
4.2.8.1 - Vectors, translation and dot products (VB.NET)Represent vectors as lists, arrays and functions, interpret their geometry, and calculate combinations, dot products and angles. This VB.NET route uses written code with no Run: incomplete: runnable support pending.

Algorithms

4.3.1.1 - Breadth-first and depth-first graph traversal (VB.NET)Learn how a queue and a stack produce different visits through the same graph. Trace each traversal, keep track of discovered vertices and choose a suitable traversal for an unweighted route or a maze.
4.3.2.1 - Tree traversals (VB.NET)Learn how moving a node's visit before, between or after its two subtree visits changes a traversal. Use those orders to copy a tree, output ordered keys and process an expression or safely empty a tree.
4.3.3.1 - Reverse Polish and infix expressions (VB.NET)Learn to move between ordinary infix expressions and Reverse Polish notation while preserving the operations and operand order. Use a stack to evaluate or reconstruct an expression and explain why postfix form is useful to an interpreter.
4.3.4.1–4.3.4.3 - Linear, binary and binary-tree search (VB.NET)Learn how linear search checks successive values, binary search narrows an ordered array, and binary-tree search follows ordered links. Trace the changing state and relate the number of comparisons to input size and tree shape.
4.3.5.1–4.3.5.2 - Bubble sort and merge sort (VB.NET)Learn how adjacent swaps move a largest value into place and how merging smaller sorted sequences builds a sorted result. Trace both sorts and explain their different growth in work as the input gets larger.
4.3.6.1 - Dijkstra's shortest-path algorithm (VB.NET)Learn to apply a supplied shortest-path algorithm to a weighted graph, update tentative distances and reconstruct a route. Distinguish the cheapest weighted route from the route using the fewest edges.

Theory of computation

4.4.1.1–4.4.1.2 - Solving problems and tracing algorithms (VB.NET)Develop a solution from explicit rules, express it as pseudocode, trace its state and convert it into VB.NET. Check why it works and what evidence could reveal a defect. VB.NET activities are written-only; this route is incomplete: runnable support pending.
4.4.1.9–4.4.1.11 - Decomposition, composition and automation (VB.NET)Break a problem into useful tasks, combine procedures and data into larger abstractions, and explain how an abstract model becomes an automated solution. VB.NET source tasks are written-only; this route is incomplete: runnable support pending.
4.4.2.3–4.4.2.4 - Regular expressions and regular languages (VB.NET)Describe sets of strings with regular expressions, use them for matching and manipulation in VB.NET, and relate simple expressions to finite-state machines. Source tasks are written-only; this route is incomplete: runnable support pending.
4.4.4.1–4.4.4.3 - Functions, growth and algorithm complexity (VB.NET)Compare growth functions, count permutations and derive time and space requirements from an algorithm's work as its input grows. VB.NET examples and source tasks are written-only; this route is incomplete: runnable support pending.
4.4.5.1 - Turing machines as a model of computation (VB.NET)Read a Turing machine's transition rules, hand-trace a simple computation and understand why the model matters. A VB.NET simulation illustrates the rules without replacing the formal machine. Source tasks are written-only; this route is incomplete: runnable support pending.

Functional programming

4.12.1.1–4.12.1.3 - Function types, first-class values and application (VB.NET)Learn how a function maps inputs to outputs, how a function itself can be a value, and how application supplies its arguments.
4.12.1.4–4.12.1.5 - Partial application and function composition (VB.NET)Learn how supplying some arguments produces a specialised function, and how composition connects one function's output to another's input.
4.12.2.1 - Higher-order functions, map, filter and fold (VB.NET)Learn to pass functions into reusable transformations, map and filter a sequence, and fold its values into one result.
4.12.3.1 - Functional lists, heads, tails and construction (VB.NET)Learn to split a list into its head and tail, build new lists at either end, and process a list through a terminating recursive function.