AQA

Level 3

QN: 601/4569/9

Curriculum Active

AQA Level 3 Advanced GCE in Computer Science

Official qualification regulated by Ofqual, awarded by AQA. Classified as a GCE A Level.

Qualification Level

Level 3

Awarding Body

AQA

Syllabus Units

3 Units

Guided Hours

Flexible

Instant access to interactive lessons, quizzes, and spaced revision.

Course Syllabus & Study Modules

Complete breakdown of verified curriculum topics and learning objectives.

Big Data

Characteristics of Big Data

Verified

Key Learning Objectives:

Define volume, velocity, variety, veracity, and value as the 5 Vs of big data.
Explain how each V imposes distinct technical requirements on data storage and processing.
Distinguish between structured, unstructured, and semi-structured data in the context of variety.
Analyse the relationship between veracity and value when drawing business conclusions.
Evaluate the trade-offs between volume and velocity in designing a big data solution.
Apply the 5 Vs framework to categorise challenges in a given case study.

Big Data

Data analytics

Verified

Key Learning Objectives:

Describe the characteristics and goals of descriptive, diagnostic, predictive, and prescriptive analytics.
Differentiate between the four analytics types by comparing their inputs, processes, and outputs.
Identify appropriate analytics approaches for given big data problems in various industries.
Explain the role of each analytics type within the overall data analytics lifecycle.

Big Data

NoSQL databases

Verified

Key Learning Objectives:

Describe the structural characteristics of key-value, document, column-family, and graph NoSQL databases.
Compare the use cases for each NoSQL database type in the context of big data applications.
Evaluate the trade-offs between consistency, availability, and partition tolerance in distributed NoSQL systems.
Explain how NoSQL databases achieve horizontal scalability through techniques such as sharding and replication.
Distinguish between ACID and BASE transaction models and their relevance to NoSQL databases.

Big Data

Processing Big Data

Verified

Key Learning Objectives:

Describe distributed processing (MapReduce, Hadoop, Spark)

Consequences of uses of computing

Cultural issues

Verified

Key Learning Objectives:

Analyse the ways globalisation, driven by computing, impacts cultural diversity and local traditions.
Evaluate the causes and consequences of the digital divide on different demographic groups.
Examine the role of social media in constructing and performing cultural identities.
Assess the ethical obligations of technologists in addressing cultural biases in digital platforms.
Compare positive and negative cultural effects of ubiquitous computing across societies.

Consequences of uses of computing

Environmental issues

Verified

Key Learning Objectives:

Analyse the environmental impact of e-waste and the challenges of disposal and recycling.
Evaluate the energy consumption of data centres and personal devices in relation to global carbon emissions.
Propose strategies for sustainable computing to reduce the environmental footprint of IT systems.
Assess the role of legislation and corporate responsibility in addressing computing's environmental issues.
Compare the environmental costs of different computing models, such as cloud versus on-premises infrastructure.

Consequences of uses of computing

Ethical issues

Verified

Key Learning Objectives:

Analyse the ethical implications of data collection practices on individual privacy.
Evaluate the societal impacts of government surveillance technologies.
Assess the fairness of algorithmic decision-making in critical areas such as criminal justice or lending.
Critique the ethical challenges posed by automation on employment and economic inequality.
Propose ethical guidelines for developing responsible AI systems.

Consequences of uses of computing

Legal issues

Verified

Key Learning Objectives:

Explain the principles and rights established by the Data Protection Act 2018 for data subjects and controllers.
Analyze scenarios involving computer misuse to determine potential offenses under the Computer Misuse Act 1990.
Evaluate the effectiveness of the Copyright, Designs and Patents Act 1988 in protecting digital intellectual property.
Apply appropriate legislation to given case studies involving computing-related legal issues.
Discuss the ethical and professional responsibilities of computing professionals in relation to these laws.

Consequences of uses of computing

Privacy and censorship

Verified

Key Learning Objectives:

Evaluate the impact of mass data collection on individual privacy rights.
Analyse the legal protections afforded by data protection laws such as GDPR.
Assess the arguments for and against internet censorship in modern democracies.
Explain how technological tools can be used to protect online privacy.
Discuss the ethical responsibilities of organisations collecting personal data.

Fundamentals of algorithms

Graph traversal algorithms

Verified

Key Learning Objectives:

Describe the algorithm steps for depth-first search using a stack and recursion.
Implement breadth-first search algorithmically using a queue to explore levels.
Analyse the time complexity of DFS and BFS in terms of vertices and edges.
Apply DFS to detect cycles in an undirected graph.
Compare the traversal order of DFS and BFS on a given graph.
Evaluate the suitability of DFS vs BFS for finding the shortest path in an unweighted graph.

Fundamentals of algorithms

Optimisation algorithms

Verified

Key Learning Objectives:

Trace the step-by-step execution of Dijkstra's algorithm on a given weighted graph
Analyse the time and space complexity of Dijkstra's algorithm using suitable data structures
Explain the role of heuristic functions in the A* algorithm and how they affect optimality
Implement Dijkstra's algorithm in a high-level language using a priority queue
Compare the behaviour of Dijkstra's and A* algorithms on specific graph problems
Evaluate the suitability of each algorithm for real-world applications such as GPS navigation

Fundamentals of algorithms

Reverse Polish notation

Verified

Key Learning Objectives:

Convert infix expressions to Reverse Polish Notation using the shunting-yard algorithm.
Evaluate RPN expressions using a stack-based approach.
Explain how operator precedence and associativity govern the conversion process.
Trace step-by-step the state of the stack and output queue during conversion and evaluation.
Detect and correct common errors in RPN expressions caused by incorrect operator ordering or missing operands.
Discuss the advantages of RPN in parsing efficiency and its applications in calculators and compilers.

Fundamentals of algorithms

Searching algorithms

Verified

Key Learning Objectives:

Describe the step-by-step process of linear search on an unsorted list
Implement binary search on a sorted array and trace its execution
Evaluate the time complexity of linear and binary search using Big O notation
Compare the efficiency of linear and binary search in best, average, and worst-case scenarios

Fundamentals of algorithms

Sorting algorithms

Verified

Key Learning Objectives:

Explain the step-by-step operation of bubble sort and derive its time complexity in best, worst, and average cases.
Implement insertion sort and evaluate its adaptive characteristics on partially sorted data.
Describe the divide-and-conquer approach used in merge sort and analyze its consistent O(n log n) performance.
Demonstrate quick sort with various pivot selection methods and justify their impact on efficiency.
Compare the stability, memory usage, and suitability of all four algorithms for different input scenarios.
Trace the execution of each sorting algorithm on a given dataset, correctly identifying intermediate states.

Fundamentals of algorithms

Tree traversal algorithms

Verified

Key Learning Objectives:

Describe the recursive algorithms for pre-order, in-order, and post-order traversal of binary trees.
Compare iterative and recursive approaches to tree traversal in terms of memory and complexity.
Apply tree traversals to evaluate arithmetic expressions represented as binary trees.
Given two traversal sequences, reconstruct the original binary tree structure.
Analyse the time and space complexity of standard depth-first tree traversal algorithms.

Fundamentals of communication and networking

Communication methods

Verified

Key Learning Objectives:

Evaluate the suitability of serial versus parallel communication for given scenarios.
Analyse the advantages and limitations of synchronous and asynchronous data transmission.
Explain how start/stop bits are used in asynchronous communication to achieve frame synchronisation.
Illustrate with examples the impact of clock skew on parallel transmission.
Apply knowledge of communication methods to recommend an appropriate protocol for a specific application.

Fundamentals of communication and networking

Network protocols

Verified

Key Learning Objectives:

Explain the purpose and operation of each layer in the TCP/IP model.
Compare and contrast HTTP and HTTPS, including the role of SSL/TLS in providing security.
Evaluate the differences between POP3 and IMAP in terms of email retrieval, storage, and synchronization.
Describe how FTP establishes control and data connections, and outline its security limitations.
Analyse the process of sending and receiving emails using SMTP, POP3, and IMAP, identifying the roles of mail servers and clients.
Apply knowledge of protocol port numbers to configure firewall rules that permit specific network services.

Fundamentals of communication and networking

Network security

Verified

Key Learning Objectives:

Explain how a firewall inspects and filters traffic using rule-based mechanisms.
Evaluate the efficacy of symmetric versus asymmetric encryption in defending network data.
Analyze the strengths and vulnerabilities of multi-factor authentication systems.
Justify the use of VPN protocols to secure data transmission over untrusted networks.

Fundamentals of communication and networking

Network topologies

Verified

Key Learning Objectives:

Distinguish between physical and logical network topologies with examples.
Analyse the impact of a single point of failure in star and ring topologies.
Compare bus and star topologies in terms of data collision handling.
Evaluate the suitability of a full mesh topology for a large-scale enterprise network.
Explain how a hybrid topology can combine benefits of multiple basic topologies.
Sketch and label typical arrangements for star, bus, ring, and partial mesh topologies.

Fundamentals of communication and networking

The internet and the World Wide Web

Verified

Key Learning Objectives:

Explain the role of routers and gateways in connecting autonomous systems on the internet.
Compare the characteristics of IPv4 and IPv6 addresses, including notation and address space.
Describe the step-by-step process of DNS resolution from browser to authoritative server.
Identify the function of each component in a given URL (e.g., https://www.example.com/path?query#fragment).
Analyse the benefits and drawbacks of using a hierarchical naming system for domains.

Fundamentals of computer organisation and architecture

Addressing modes

Verified

Key Learning Objectives:

Describe the role of addressing modes in the fetch-decode-execute cycle
Differentiate between immediate, direct, indirect, indexed, and relative addressing modes using assembly language examples
Evaluate the suitability of each addressing mode for different programming tasks such as accessing array elements, constants, and dynamically allocated memory
Apply addressing mode concepts to calculate effective addresses and predict memory accesses
Analyse the impact of addressing mode choice on code size and execution speed

Fundamentals of computer organisation and architecture

Instruction sets

Verified

Key Learning Objectives:

Describe the key characteristics of CISC and RISC architectures.
Compare CISC and RISC architectures in terms of instruction complexity, pipelining, and performance.
Explain the role of addressing modes in instruction set design.
Evaluate the impact of instruction set choice on system performance and power consumption.
Analyse how instruction formats affect decoding complexity and pipeline efficiency.

Fundamentals of computer organisation and architecture

Internal components of a computer

Verified

Key Learning Objectives:

Explain the role of the CPU in the fetch-decode-execute cycle
Compare and contrast volatile and non-volatile memory types in terms of purpose and performance
Analyse how bus width and clock speed affect data transfer rates
Evaluate the impact of motherboard form factor on system expansion and cooling
Describe the function of common I/O ports and their associated communication protocols

Fundamentals of computer organisation and architecture

Processor performance

Verified

Key Learning Objectives:

Explain the relationship between clock speed, cycles per instruction (CPI), and overall processor performance.
Analyse how increasing the number of processor cores affects performance for parallel versus serial workloads, referencing Amdahl's Law.
Evaluate the impact of cache size, levels, and hit rate on reducing average memory access time.
Describe the stages of instruction pipelining and identify potential hazards that reduce its efficiency.
Compare the effectiveness of clock speed enhancements, multi-core architectures, and pipelining in improving performance for specific computing scenarios.

Fundamentals of computer organisation and architecture

The stored program concept

Verified

Key Learning Objectives:

Explain the fetch-execute cycle and the role of the program counter.
Describe the stored program concept and its historical significance.
Distinguish between instruction and data memory in the von Neumann model.
Analyze the interaction between the program counter, memory address register, and memory data register during instruction fetch.
Evaluate the advantages and limitations of the stored program concept in modern processors.

Fundamentals of computer systems

Classification of programming languages

Verified

Key Learning Objectives:

Distinguish between low-level and high-level programming languages with reference to their characteristics and typical applications
Explain the role of translators (assemblers, compilers, interpreters) in converting source code to machine-executable form
Compare the portability and efficiency trade-offs between machine code, assembly, and high-level languages
Evaluate the suitability of low-level versus high-level languages for specific programming scenarios such as embedded systems or scientific computing
Describe how high-level language constructs map to low-level operations via compilation or interpretation

Fundamentals of computer systems

Hardware and software

Verified

Key Learning Objectives:

Differentiate between hardware and software using specific examples from modern computer systems.
Explain the role of an operating system as a platform for application software and resource management.
Analyse the relationship between hardware capabilities and software requirements in a given computing scenario.
Evaluate the impact of hardware and software choices on system performance and user experience.
Classify given software examples as system software or application software, justifying classifications.
Describe the function of common utility software and their role in maintaining computer systems.

Fundamentals of computer systems

Input and output devices

Verified

Key Learning Objectives:

Describe common input and output devices, explaining their basic functions and typical uses
Compare the operation and suitability of different input device technologies (e.g., capacitive vs resistive touchscreens)
Evaluate the impact of output device characteristics (e.g., resolution, refresh rate) on user experience
Explain how data from sensors is captured, converted, and transmitted to a processor
Justify the choice of input/output devices for a given scenario, considering cost, speed, accuracy, and user needs

Fundamentals of computer systems

Interrupts

Verified

Key Learning Objectives:

Explain the role of interrupts in enabling asynchronous event handling and improving CPU efficiency.
Describe the sequence of steps from interrupt request to return from interrupt, including context saving and vectoring.
Distinguish between hardware interrupts, software interrupts, and exceptions, giving examples of each.
Analyse the impact of interrupt priority systems on system responsiveness and fairness.
Evaluate the use of interrupt masking for critical section protection and its potential pitfalls.

Fundamentals of computer systems

Logic gates and Boolean algebra

Verified

Key Learning Objectives:

Describe the function and construct truth tables for each basic logic gate (AND, OR, NOT, NAND, NOR, XOR).
Simplify Boolean expressions using algebraic manipulation and De Morgan's theorems.
Derive a logic gate circuit diagram from a given Boolean expression or truth table.
Evaluate the equivalence of two Boolean expressions using algebraic methods or truth tables.
Apply Karnaugh maps to minimize Boolean expressions up to four variables.

Fundamentals of computer systems

Memory organisation

Verified

Key Learning Objectives:

Contrast the purpose, volatility, and typical use cases of RAM, ROM, and cache memory
Examine the role of virtual memory in supporting multitasking and addressing memory limitations
Analyse the structure of a memory hierarchy in terms of decreasing cost per bit, increasing capacity, and increasing access time
Evaluate the impact of cache size, associativity, and replacement policies on system performance
Explain how paging and segmentation facilitate virtual memory management in modern operating systems

Fundamentals of computer systems

Processor architecture

Verified

Key Learning Objectives:

Describe the Von Neumann architecture and explain the roles of its core components: the central processing unit (CPU), memory unit, and input/output (I/O) systems.
Explain the fetch-decode-execute cycle, detailing the register transfers at each stage.
Compare the Von Neumann architecture with the Harvard architecture, highlighting the implications of shared versus separate buses.
Evaluate the performance constraints of the Von Neumann architecture, such as the bottleneck problem.
Identify and describe the function of key CPU components, including the arithmetic logic unit (ALU), control unit (CU), and various registers.
Diagram the data and address flow within a Von Neumann machine during program execution.

Fundamentals of computer systems

Secondary storage

Verified

Key Learning Objectives:

Describe the operational principles of magnetic, optical, and solid-state storage.
Explain the underlying technologies for each storage type, including read/write mechanisms.
Compare the key characteristics of capacity, speed, durability, and portability across the three types.
Evaluate the suitability of different secondary storage media for specific applications.
Analyze the performance trade-offs between magnetic and solid-state storage.

Fundamentals of computer systems

The processor instruction set

Verified

Key Learning Objectives:

Define the components of an instruction and differentiate between opcode and operand fields.
Explain the purpose and operation of immediate, direct, indirect, and indexed addressing modes.
Calculate effective memory addresses given register and offset values for different addressing modes.
Assess the advantages and limitations of each addressing mode in terms of execution speed and memory usage.
Translate simple high-level program statements into equivalent assembly code using appropriate addressing modes.
Analyse the impact of indexing on array processing and looping structures.

Fundamentals of computer systems

Types of program translator

Verified

Key Learning Objectives:

Describe the purpose and function of an assembler in translating assembly language to machine code.
Explain the differences between compilation and interpretation, including their respective advantages and disadvantages.
Evaluate the suitability of using an interpreter versus a compiler for a given scenario.
Identify the role of intermediate representations in modern compiler design.
Compare the execution speed and portability of code processed by compilers and interpreters.

Fundamentals of data representation

Binary arithmetic and representation

Verified

Key Learning Objectives:

Represent given positive and negative decimal integers in both sign-magnitude and two's complement binary forms.
Perform binary addition and subtraction using two's complement arithmetic, including the handling of carry and overflow.
Analyse the range of representable numbers for a given number of bits in sign-magnitude versus two's complement formats.
Evaluate the suitability of sign-magnitude and two's complement representations for efficient arithmetic in computer systems.
Identify and correct common misconceptions regarding negative zero and overflow in signed binary arithmetic.

Fundamentals of data representation

Bitwise manipulation and masks

Verified

Key Learning Objectives:

Apply bitwise AND, OR, XOR, and NOT operations to binary sequences.
Use logical and arithmetic shift operations to manipulate binary data.
Construct masks to isolate, set, clear, or toggle specific bits within a byte or word.
Evaluate the efficiency of bitwise techniques over conventional arithmetic for specific tasks (e.g., multiplication/division by powers of two).
Debug bit-level code to identify errors in mask application or operator precedence.

Fundamentals of data representation

Character encoding

Verified

Key Learning Objectives:

Define a character set and explain the need for standardised encoding in digital communication.
Describe the 7-bit ASCII encoding scheme and its range of representable characters.
Identify the limitations of ASCII for internationalisation and multilingual support.
Explain the concept of Unicode as a universal character set with over a million code points.
Distinguish between code points, code units, and encoding forms in Unicode.
Compare UTF-8 and UTF-16 encoding mechanisms, focusing on byte usage and ASCII compatibility.
Analyse scenarios where UTF-8 or UTF-16 is more appropriate based on data characteristics.
Evaluate the impact of character encoding choices on data size, processing speed, and cross-platform compatibility.

Fundamentals of data representation

Data compression

Verified

Key Learning Objectives:

Explain the difference between lossless and lossy compression, including their respective advantages and disadvantages.
Apply run-length encoding to compress and decompress a given sequence of symbols.
Construct a Huffman tree from a frequency table and derive the corresponding Huffman codes for each symbol.
Calculate and interpret compression ratios for different compression techniques.
Evaluate the suitability of lossy compression for different types of media, considering factors such as perceptibility and data fidelity.

Fundamentals of data representation

Encryption

Verified

Key Learning Objectives:

Explain the operational principles of symmetric and asymmetric encryption.
Compare symmetric and asymmetric encryption in terms of speed, key length, and security.
Analyse how hybrid encryption combines the strengths of both approaches for efficient secure communication.
Evaluate the importance of key size and computational complexity in resisting brute force and cryptographic attacks.
Apply encryption concepts to justify the use of digital signatures and certificates in secure web browsing.

Fundamentals of data representation

Floating point numbers

Verified

Key Learning Objectives:

Explain the need for floating point representation in computer systems.
Apply the IEEE 754 standard to convert denary numbers into binary floating point format.
Analyse the effects of limited mantissa bits on calculation precision.
Evaluate the trade-offs between range and precision in floating point representation.

Fundamentals of data representation

Number systems

Verified

Key Learning Objectives:

Convert accurately between binary, decimal, hexadecimal, and octal number systems.
Explain why hexadecimal is used in computing as a more human-readable representation of binary.
Apply grouping techniques to efficiently convert between binary and hexadecimal or octal.
Compare the storage efficiency of different number bases in digital systems.

Fundamentals of data representation

Representation of images

Verified

Key Learning Objectives:

Describe the structure of a bitmap image in terms of pixels and colour depth
Explain how vector graphics represent shapes using mathematical primitives
Calculate bitmap file sizes given image dimensions and colour depth
Compare the scalability and file size implications of bitmap and vector representations
Evaluate the suitability of bitmap versus vector formats for different scenarios

Fundamentals of data representation

Representation of sound

Verified

Key Learning Objectives:

Represent sound as digital samples (sampling rate, bit depth)
Explain the relationship between sampling rate, frequency range, and sound quality using the Nyquist theorem.
Calculate the file size of an uncompressed monophonic or stereo sound file.
Evaluate the impact of bit depth on dynamic range and signal-to-noise ratio.
Describe the steps involved in ADC for sound, including sampling and quantisation.

Fundamentals of data structures

Data structures and arrays

Verified

Key Learning Objectives:

Explain the memory organisation and index-based access mechanism of one-dimensional arrays.
Implement algorithms to iterate over, search, and modify elements within one-dimensional arrays.
Demonstrate the declaration and initialisation of two-dimensional arrays for tabular data.
Apply nested loops to perform row-wise and column-wise traversals of two-dimensional arrays.
Evaluate the efficiency of common array operations in terms of time and space complexity.
Compare the characteristics of arrays with other static and dynamic data structures.

Fundamentals of data structures

Dictionaries

Verified

Key Learning Objectives:

Explain the dictionary ADT and its characteristic key-value mapping
Implement dictionary operations (insert, retrieve, delete) using a chosen representation
Compare the efficiency of dictionary implementations (hash table, tree, list) for given scenarios
Analyse the time and space complexity of dictionary operations under different load factors
Apply a dictionary to solve a practical problem such as frequency counting or caching
Evaluate the suitability of various collision resolution techniques (chaining, open addressing) for a specific application

Fundamentals of data structures

Graphs

Verified

Key Learning Objectives:

Define graphs and their components (nodes, edges, directed/undirected).
Construct adjacency matrix and adjacency list representations from a given graph.
Compare adjacency matrix and adjacency list in terms of space and time complexity.
Explain and apply the depth-first search (DFS) algorithm to traverse a graph.
Explain and apply the breadth-first search (BFS) algorithm to traverse a graph.
Analyse the suitability of each graph representation for different types of graph problems.

Fundamentals of data structures

Hash tables

Verified

Key Learning Objectives:

Explain the purpose and operation of a hash table.
Apply a hash function to convert keys into indices.
Implement chaining collision resolution using linked lists.
Implement open addressing collision resolution using linear probing.
Compare the efficiency of chaining and open addressing under varying load factors.
Evaluate the need for rehashing when the load factor exceeds a threshold.

Fundamentals of data structures

Lists

Verified

Key Learning Objectives:

Describe the structure of a node in a linked list and how nodes are linked via pointers.
Implement functions to insert a node at the head, tail, or a given index of a linked list.
Implement functions to delete a node by value or position, ensuring correct pointer reassignment.
Write an iterative algorithm to traverse a linked list and search for a specific element.
Evaluate the time and space complexity of common linked list operations.
Compare the advantages and disadvantages of linked lists with arrays for dynamic data storage.

Fundamentals of data structures

Queues

Verified

Key Learning Objectives:

Implement enqueue and dequeue operations for a linear queue using an array
Explain how the peek operation retrieves the front element without removal
Describe the conditions that trigger isEmpty and isFull methods
Implement a circular queue to optimize memory utilization
Compare the efficiency of array-based and linked-list queue implementations

Fundamentals of data structures

Records

Verified

Key Learning Objectives:

Explain the purpose and advantages of using records over individual variables.
Define a record type with appropriate field names and data types.
Implement record operations including assignment, field access, and comparison.
Describe how records are stored in memory and the implications for parameter passing.
Use nested records to model hierarchical data structures.

Fundamentals of data structures

Stacks

Verified

Key Learning Objectives:

Describe the LIFO nature of stack data structures.
Implement a stack using both static arrays and dynamic linked lists.
Evaluate the time and space complexity of stack operations.
Apply stack algorithms to solve problems such as depth-first search or undo functionality.
Diagnose stack overflow and underflow errors in code.
Compare and contrast static and dynamic stack implementations.

Fundamentals of data structures

Trees

Verified

Key Learning Objectives:

Implement insertion and search operations for a binary search tree using both iterative and recursive approaches.
Apply in-order, pre-order, and post-order traversal algorithms to produce a sequence of node values and explain their practical use cases.
Analyse the three cases of node deletion in a BST (leaf, one child, two children) and implement the deletion algorithm correctly.
Evaluate the time complexity of BST operations and discuss the impact of tree balance on performance.
Compare the properties of binary trees and binary search trees, and justify the choice of appropriate traversal method for a given problem.

Fundamentals of databases

Database design and normalisation

Verified

Key Learning Objectives:

Define the rules that a relation must satisfy to be in first, second, and third normal form
Identify partial dependencies and transitive dependencies in a given unnormalised table
Apply the steps of normalisation to convert a dataset from unnormalised form to 3NF
Evaluate the trade-offs between normalised and denormalised database designs

Fundamentals of databases

Relational databases

Verified

Key Learning Objectives:

Define the fundamental components of a relational database: tables, records, fields, primary keys, foreign keys, and relationships.
Explain the function of primary and foreign keys in enforcing data integrity and establishing relationships.
Differentiate between one-to-one, one-to-many, and many-to-many relationships using concrete examples.
Construct a simple relational schema from a given set of requirements, identifying entities, attributes, and keys.
Analyze a given database design to identify potential redundancy and integrity issues.

Fundamentals of databases

Security and integrity

Verified

Key Learning Objectives:

Explain the role of access controls in database security, including user authentication and authorization mechanisms.
Evaluate the strengths and weaknesses of different encryption methods for protecting data at rest and in transit.
Design a backup and recovery plan for a given scenario, considering full, incremental, and differential backups.
Apply integrity constraints (e.g., primary keys, foreign keys, NOT NULL, CHECK) to ensure data validity in a relational database schema.
Analyse the impact of SQL injection attacks on database security and propose mitigation strategies.

Fundamentals of databases

Structured Query Language (SQL)

Verified

Key Learning Objectives:

Construct SQL SELECT queries to retrieve specified data from single and multiple tables using appropriate filtering and sorting.
Apply INSERT, UPDATE, and DELETE statements to modify database contents while maintaining data integrity.
Design queries using various JOIN types (e.g., INNER, LEFT, RIGHT) to integrate related data from multiple tables.
Implement GROUP BY clauses with aggregate functions to summarize data at different levels of granularity.
Differentiate between WHERE and HAVING clauses to correctly filter rows before and after grouping.
Analyze SQL query outputs to verify correctness and identify potential errors in logic or syntax.

Fundamentals of databases

Transaction processing

Verified

Key Learning Objectives:

Describe the ACID properties (Atomicity, Consistency, Isolation, Durability) and their role in transaction processing.
Explain how atomicity is enforced using commit and rollback operations.
Analyse the impact of different isolation levels on data consistency and performance.
Evaluate trade-offs between strict isolation and system throughput in concurrent transactions.
Apply the concept of durability to design a recovery strategy after a system crash.
Assess how consistency ensures database validity across multiple simultaneous transactions.

Fundamentals of functional programming

Function application

Verified

Key Learning Objectives:

Apply function application to evaluate expressions in a functional programming language.
Implement higher-order functions that take other functions as arguments or return functions as results.
Use the map function to transform each element of a list according to a given function.
Use the filter function to select elements from a list based on a predicate.
Use the reduce function to combine elements of a list into a single value using a binary operation.
Compare the use of map, filter, and reduce with traditional iteration constructs.

Fundamentals of functional programming

Functional programming paradigm

Verified

Key Learning Objectives:

Define pure functions and distinguish them from impure functions.
Explain the concept of immutability and its role in preventing unintended state changes.
Identify examples of side effects in code and evaluate their impact on program reliability.
Describe referential transparency and demonstrate how it follows from purity and immutability.
Compare the functional paradigm with the imperative paradigm, highlighting key differences in state management.
Apply functional techniques such as recursion and higher-order functions to avoid mutable state.
Analyse a given code snippet to determine whether it adheres to functional programming principles.

Fundamentals of functional programming

Lists in functional programming

Verified

Key Learning Objectives:

Apply the head function to retrieve the first element of a non-empty list.
Use the tail function to obtain a list without its first element.
Construct new lists by prepending elements with the cons operator.
Calculate the length of a list using a recursive function.
Combine two lists using the append function to produce a new list.
Distinguish between operations that produce new lists and those that retrieve elements.

Fundamentals of functional programming

Types in functional programming

Verified

Key Learning Objectives:

Define algebraic data types, including sum types and product types, with examples.
Explain how the type system in functional programming contributes to program correctness.
Infer the types of expressions in a simple functional language.
Construct custom data structures using sum and product type definitions.
Apply pattern matching to deconstruct and process algebraic data types.

Fundamentals of programming

Arithmetic operations in a programming language

Verified

Key Learning Objectives:

Perform basic arithmetic operations (+, -, *, /) on numeric data types.
Distinguish between real division and integer division, explaining how rounding or truncation occurs.
Apply the modulus operator to solve problems such as checking divisibility or extracting digits.
Evaluate arithmetic expressions involving mixed data types, identifying implicit and explicit type conversions.
Construct expressions with correct operator precedence to achieve desired computational results.

Fundamentals of programming

Boolean operations in a programming language

Verified

Key Learning Objectives:

Apply AND, OR, NOT, XOR operators to construct conditional statements
Construct truth tables for compound Boolean expressions
Evaluate Boolean expressions considering operator precedence
Distinguish between logical and bitwise operations
Combine multiple Boolean operators to form complex conditions
Analyse the effect of short-circuit evaluation on program execution

Fundamentals of programming

Constants and variables in a programming language

Verified

Key Learning Objectives:

Differentiate between constants and variables in terms of immutability and memory behavior
Explain the concept of scope and its effect on variable accessibility and lifetime
Apply appropriate naming conventions for constants and variables to enhance code clarity
Declare variables with correct data types and initial values following language syntax
Evaluate the impact of poorly scoped variables on program reliability and maintainability
Use constants to prevent unintended modifications and convey semantic meaning

Fundamentals of programming

Data types

Verified

Key Learning Objectives:

Define and use integer, real, Boolean, character, string, and pointer data types in program code
Explain the internal binary representation of integer (two's complement) and real (floating-point) numbers
Analyze the implications of fixed-size storage, including overflow and underflow errors
Evaluate the use of pointers for dynamic memory management and indirect data access
Apply explicit type casting and understand implicit type coercion in expressions
Demonstrate safe pointer operations, including dereferencing and pointer arithmetic

Fundamentals of programming

Exception handling

Verified

Key Learning Objectives:

Define the purpose of exception handling in software development.
Apply try-catch blocks to handle specific exception types in a program.
Demonstrate the use of throw to raise exceptions and finally to ensure cleanup.
Evaluate the appropriateness of exception handling for different error scenarios.
Analyze the control flow during exception propagation in nested try blocks.

Fundamentals of programming

Programming concepts

Verified

Key Learning Objectives:

Declare and initialise variables with appropriate data types and meaningful identifiers
Utilise constant values to enhance code clarity and maintainability where data should not change
Apply arithmetic, relational, and logical operators to construct and evaluate expressions
Employ input statements to capture user-entered data and output statements to display results effectively
Use assignment statements to update variable values and track program state changes
Predict the outcome of code snippets that combine multiple operators, considering precedence rules

Fundamentals of programming

Random number generation in a programming language

Verified

Key Learning Objectives:

Identify the difference between true random and pseudo-random number generation.
Implement random number generation within a given range using a programming language's standard library.
Explain the role of seeding in deterministic random number generation.
Evaluate the suitability of random number generation for modelling real-world probabilistic scenarios.

Fundamentals of programming

Relational operations in a programming language

Verified

Key Learning Objectives:

Apply relational operators to construct compound conditions using logical connectives
Evaluate the outcome of relational expressions using truth tables and short-circuit evaluation
Analyze the impact of operator precedence on the evaluation of relational and logical expressions
Construct algorithms that use relational operations for input validation and decision branching

Fundamentals of programming

String handling operations in a programming language

Verified

Key Learning Objectives:

Apply functions to determine the length of a given string.
Locate the position of a character or substring within a string.
Extract substrings from a larger string using start and end indices.
Construct new strings by concatenating two or more strings.
Perform type conversions between strings and other data types (e.g., integer to string, string to integer).
Compare two strings lexicographically or for equality.

Fundamentals of programming

Subroutines (procedures/functions)

Verified

Key Learning Objectives:

Define subroutines, distinguishing between procedures and functions, and explain their roles in structured programming.
Construct subroutines that accept parameters by value and by reference, and demonstrate the effect on argument data.
Implement functions that return values of appropriate data types, and use these values in calling code.
Analyze the use of local and global variables within subroutines, explaining scope and lifetime.
Evaluate the benefits of using subroutines, including code reuse, readability, and ease of debugging.

Systematic approach to problem solving

Algorithms for problem solving

Verified

Key Learning Objectives:

Construct a flowchart to represent a simple sequential, selection, or iterative algorithm
Write pseudocode for a given problem statement using appropriate constructs (e.g., IF...THEN...ELSE, WHILE loops)
Translate an algorithm between representations: pseudocode to flowchart, and vice versa
Apply decomposition to break down a complex problem into manageable sub-problems for algorithm design
Evaluate the suitability of different algorithm representation methods for various contexts

Systematic approach to problem solving

Evaluation criteria

Verified

Key Learning Objectives:

Define the evaluation criteria of correctness, efficiency, usability, and maintainability in the context of software solutions.
Analyse a given solution to determine whether it meets its specified functional requirements (correctness).
Measure the efficiency of an algorithm or program in terms of time and space complexity.
Assess the usability of a software system using standard heuristics or user testing.
Evaluate the maintainability of code by considering factors such as readability, modularity, and documentation.
Justify trade-offs between conflicting evaluation criteria when selecting a solution.

Systematic approach to problem solving

Problem solving stages

Verified

Key Learning Objectives:

Analyse a given problem statement to identify functional and non-functional requirements.
Design a solution using appropriate techniques such as structure diagrams, pseudocode, and flowcharts.
Implement a solution in a suitable programming language, utilising modular programming and data structures.
Apply systematic testing strategies including unit testing, integration testing, and acceptance testing to validate the solution.
Evaluate the final solution against original requirements, identifying strengths, limitations, and potential improvements.

Systematic approach to problem solving

Testing strategies

Verified

Key Learning Objectives:

Distinguish between black-box and white-box testing approaches and their appropriate contexts of use.
Construct unit test cases utilising normal, boundary, and erroneous data to verify module functionality.
Describe the process of integration testing, including the selection of incremental integration strategies.
Explain the significance of acceptance testing in confirming that the system meets stakeholder requirements.
Evaluate the effectiveness of a given test strategy in identifying defects at different development stages.

Theory of computation

Abstraction and automation

Verified

Key Learning Objectives:

Explain how abstraction reduces complexity in problem-solving by modeling essential features.
Distinguish between representational abstraction and procedural abstraction with concrete examples.
Apply abstraction to create a simplified representation of a real-world scenario for computational processing.
Analyse the relationship between abstraction and automation in the development of algorithmic solutions.
Evaluate the effectiveness of different abstraction levels when designing a computational model for a given task.
Construct a finite state machine to automate a simple process based on abstracted transitions.

Theory of computation

Complexity theory

Verified

Key Learning Objectives:

Define P, NP, NP-complete, and NP-hard problems
Explain the significance of the P vs NP problem
Apply reduction techniques to demonstrate NP-completeness
Analyze whether a given problem belongs to P, NP, or NP-complete
Evaluate the role of heuristic algorithms for NP-hard problems

Theory of computation

Computability and decidability

Verified

Key Learning Objectives:

Explain the halting problem and its implications
Distinguish between decidable, undecidable, and semi-decidable problems
Analyse a proof of undecidability using diagonalisation or reduction
Evaluate the significance of the Church-Turing thesis for computational limits
Apply the concept of undecidability to assess the feasibility of automated software verification

Theory of computation

Context-free languages

Verified

Key Learning Objectives:

Describe the components of a context-free grammar and illustrate how derivations generate strings.
Construct a pushdown automaton that recognises a specified context-free language.
Analyse a given context-free grammar to determine the language it generates.
Explain the equivalence between context-free grammars and pushdown automata.
Apply the pumping lemma for context-free languages to demonstrate that a language is not context-free.

Theory of computation

Finite state machines (FSMs)

Verified

Key Learning Objectives:

Design a deterministic finite state machine to solve a specified problem, incorporating both Mealy and Moore output conventions.
Interpret a given state transition diagram or table, identifying the type (Mealy or Moore) and describing its behaviour in plain language.
Differentiate between Mealy and Moore machines in terms of their output timing and state dependencies.
Evaluate the trade-offs between Mealy and Moore implementations for a given real-world application.

Theory of computation

Regular languages

Verified

Key Learning Objectives:

Define regular languages using regular expressions and finite automata
Construct deterministic and non-deterministic finite automata for given regular languages
Convert between regular expressions and finite automata using algorithmic methods
Analyze the language accepted by a given finite automaton

Theory of computation

Turing machines

Verified

Key Learning Objectives:

Describe the components and operation of a Turing machine, including the infinite tape, read/write head, and state register.
Explain how transition rules govern the behaviour of a Turing machine.
Design simple Turing machines for tasks such as binary increment or palindrome recognition.
Analyse the concept of a universal Turing machine and its role in the Church-Turing thesis.
Evaluate the limitations of computation by identifying undecidable problems like the halting problem.

Regulatory & Verification Details

Qualification Number (QN): 601/4569/9
Regulated Status: Available to learners
Awarding Body: AQA
Qualification Type: GCE A Level
Operational Start: Sept 2015