AQA A Level Computer Science — Complete Revision Guide for Both Papers (7517)

AQA A Level Computer Science (7517) is examined across two papers. This guide covers all the major topics for both with the mark-scheme vocabulary, worked examples and exam tips that make the difference between grades.

• Paper 1 (7517/1) — on-screen exam, 2.5 hours, 100 marks: Computational thinking, problem solving and programming
• Paper 2 (7517/2) — written exam, 2.5 hours, 100 marks: Computer systems

---

PAPER 1 — Computational Thinking, Problem Solving and Programming

Paper 1 is an on-screen exam where you write Python code (or the AQA pseudo-code subset) to solve problems. Questions range from short code-reading tasks to longer algorithm design and implementation.

---

1. Fundamentals of Programming

Data types you must know:

Type	Example	Notes
Integer	42	Whole numbers; no decimal point
Real/Float	3.14	Decimal numbers
Boolean	True, False	Only two values
String	"hello"	Sequence of characters
Character	"A"	Single character

Key string operations:

s = "Computer"
len(s)           # 8
s.upper()        # "COMPUTER"
s.lower()        # "computer"
s[0]             # "C"
s[3:7]           # "pute"
s + " Science"   # "Computer Science"
"put" in s       # True

Type casting:

int("42")        # 42
float("3.14")    # 3.14
str(99)          # "99"
bool(0)          # False (0 = False, anything else = True)

Records (structures): AQA uses class or named tuples for structured data grouping related fields.

---

2. Programming Techniques

Selection:

grade = int(input("Score: "))
if grade >= 70:
    print("A")
elif grade >= 60:
    print("B")
elif grade >= 50:
    print("C")
else:
    print("U")

Iteration — count-controlled:

for i in range(1, 11):   # 1 to 10 inclusive
    print(i * i)

Iteration — condition-controlled:

total = 0
number = int(input("Enter number (-1 to stop): "))
while number != -1:
    total += number
    number = int(input("Enter number (-1 to stop): "))
print("Total:", total)

Subroutines — procedures and functions:

# Procedure (no return value)
def print_table(n):
    for i in range(1, 13):
        print(f"{i} × {n} = {i * n}")

# Function (returns a value)
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)   # recursive

Local vs global scope:

• Variables defined inside a function are local — only accessible within that function
• Variables defined outside are global — use global x inside a function to modify them
• Good practice: avoid global variables; pass parameters instead

---

3. Data Structures

Arrays / Lists

# 1D array
scores = [72, 65, 89, 91, 58]
scores[0]         # 72 (zero-indexed)
scores[-1]        # 58 (last element)
len(scores)       # 5
scores.append(77) # add to end
scores.sort()     # sort in place

# 2D array (list of lists)
grid = [[1,2,3], [4,5,6], [7,8,9]]
grid[1][2]        # 6 (row 1, column 2)

Stacks

LIFO (Last In, First Out). Operations: push, pop, peek, isEmpty, isFull.

class Stack:
    def __init__(self):
        self._data = []

    def push(self, item):
        self._data.append(item)

    def pop(self):
        if self.is_empty():
            raise IndexError("Stack underflow")
        return self._data.pop()

    def peek(self):
        return self._data[-1]

    def is_empty(self):
        return len(self._data) == 0

Uses: call stack (function calls), undo/redo, expression evaluation, DFS, backtracking.

Queues

FIFO (First In, First Out). Operations: enqueue, dequeue, peek, isEmpty.

A circular queue uses modulo arithmetic to wrap around: back = (back + 1) % capacity. This avoids “queue creep”.

Uses: CPU scheduling, print spooling, BFS, network packet queuing.

Linked lists

Nodes containing data and a pointer to the next node. Advantages over arrays: O(1) insertion/deletion at known position; no fixed size. Disadvantages: O(n) access by index; extra memory for pointers.

Trees

Binary tree: each node has at most two children (left, right).

Binary search tree (BST): left subtree < node < right subtree.

• Insert, search: O(log n) average, O(n) worst (degenerate/unbalanced)

Tree traversals:

• Pre-order (NLR): node → left → right (useful for copying)
• In-order (LNR): left → node → right (gives sorted output for BST)
• Post-order (LRN): left → right → node (useful for deletion)

Examples — given tree with root 5, left 3, right 7, left.left 1, left.right 4:

• Pre-order: 5, 3, 1, 4, 7
• In-order: 1, 3, 4, 5, 7 ← sorted!
• Post-order: 1, 4, 3, 7, 5

Hash tables

Hash function maps keys to array indices. O(1) average for insert, lookup, delete.

Collision: two keys map to same index. Resolved by:

• Open addressing (linear probing): try next available slot
• Chaining: each slot holds a linked list

Load factor = items / capacity. Keep below ~0.7 for good performance.

Graphs

Vertices connected by edges. Can be directed or undirected; weighted or unweighted.

Representations:

• Adjacency matrix: 2D array; O(V²) space; fast to check if edge exists
• Adjacency list: list of neighbours per vertex; O(V+E) space; efficient for sparse graphs

---

4. Algorithms

Searching

Linear search: O(n) — check each item. Works on unsorted data.

Binary search: O(log n) — requires sorted data. Halve search space each time.

1. mid = (low + high) // 2
2. If arr[mid] == target → found
3. If arr[mid] < target → low = mid + 1
4. If arr[mid] > target → high = mid − 1

Sorting

Bubble sort: O(n²) — compare adjacent pairs, swap if out of order.

• Best case O(n) with early termination (already sorted)
• Stable, in-place

Merge sort: O(n log n) — divide and conquer.

1. Split in half repeatedly until single items
2. Merge pairs in sorted order

Quick sort: O(n log n) average, O(n²) worst — pivot partitioning.

Graph algorithms

Breadth-first search (BFS):

• Uses a queue
• Explores level by level
• Finds shortest path in unweighted graphs
• O(V + E)

Depth-first search (DFS):

• Uses a stack (or recursion)
• Explores one path to its end before backtracking
• Used for: cycle detection, topological sort, maze solving
• O(V + E)

Dijkstra’s shortest path:

• Uses a priority queue (min-heap)
• Finds shortest path from source to all nodes in weighted graph
• Does NOT work with negative weights
• O((V + E) log V) with a heap

Algorithm:
1. Set dist[source] = 0, all others = ∞
2. Add all nodes to priority queue (ordered by dist)
3. While queue not empty:
   a. Extract node u with minimum distance
   b. For each neighbour v of u:
      if dist[u] + weight(u,v) < dist[v]:
          dist[v] = dist[u] + weight(u,v)   # relax edge

Time complexity

Complexity	Name	Example
O(1)	Constant	Dictionary lookup, array access
O(log n)	Logarithmic	Binary search
O(n)	Linear	Linear search
O(n log n)	Linearithmic	Merge sort, quick sort (average)
O(n²)	Quadratic	Bubble sort, selection sort
O(2ⁿ)	Exponential	Naive recursive Fibonacci

Space complexity measures memory used, using the same notation.

---

5. Theory of Computation

Abstraction and decomposition

• Abstraction: hiding irrelevant detail; representing a system at an appropriate level
• Decomposition: breaking complex problems into smaller sub-problems

Levels of abstraction:

• Problem level → algorithm → program → machine code → electronic signals

Finite state machines (FSMs)

A DFA (Deterministic Finite Automaton) consists of:

• States (Q) — finite set of states
• Alphabet (Σ) — input symbols
• Transition function (δ) — δ(state, symbol) → next state
• Start state (q₀)
• Accepting states (F)

A string is accepted if processing it from q₀ ends in a state ∈ F.

Exam tip: For a DFA question, draw the state diagram first, then trace the given strings through it.

Regular languages

Regular expressions describe patterns:

• . = any character
• * = zero or more
• + = one or more
• ? = zero or one
• [abc] = character class
• ^ = start, $ = end

Every regular expression has an equivalent FSM (Kleene’s theorem).

Context-free grammars

Used to define the syntax of programming languages. Production rules use terminals and non-terminals:

<sentence> → <noun-phrase> <verb-phrase>
<noun-phrase> → the <noun>
<noun> → cat | dog

Parse trees show how a string is derived from the grammar.

The Halting Problem

Alan Turing proved in 1936 that no algorithm can determine for all possible program-input pairs whether a program will halt. This is an undecidable problem.

Proof by contradiction: assume HALT(P, I) exists. Build Trouble(P): if HALT(P,P) then loop forever, else halt. Running Trouble(Trouble) creates a contradiction. Therefore HALT cannot exist.

---

6. OOP — Object-Oriented Programming

Four pillars:

1. Encapsulation — data and methods bundled together; private attributes hidden from outside
2. Inheritance — a subclass inherits from a parent class; “is-a” relationship
3. Polymorphism — same method name, different behaviour in different classes
4. Abstraction — hiding implementation details behind a clean interface

class Animal:
    def __init__(self, name, sound):
        self._name = name      # protected (single underscore convention)
        self.__sound = sound   # private (name mangling)

    def speak(self):
        return f"{self._name} says {self.__sound}"

class Dog(Animal):
    def __init__(self, name):
        super().__init__(name, "Woof")

    def speak(self):   # polymorphism: overrides parent
        return f"{self._name} barks: Woof woof!"

dog = Dog("Rex")
print(dog.speak())   # Rex barks: Woof woof!

Key vocabulary:

• Class — blueprint/template for objects
• Object — instance of a class
• Constructor — __init__ method, initialises the object
• Attribute — data stored in an object
• Method — function defined in a class
• Instance method — takes self as first parameter
• Class method — @classmethod, takes cls; shared across all instances
• Abstract class — cannot be instantiated; defines interface for subclasses

---

7. Functional Programming

Key principles:

• Pure functions — same output for same input; no side effects
• Immutability — data is never modified; new data is created
• First-class functions — functions can be passed as arguments, returned from functions

# Higher-order functions
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

squares = list(map(lambda x: x**2, numbers))     # [1,4,9,16,25,...]
evens   = list(filter(lambda x: x%2==0, numbers))# [2,4,6,8,10]

from functools import reduce
total = reduce(lambda a, b: a + b, numbers)       # 55

# Partial application
from functools import partial
def power(base, exponent):
    return base ** exponent

square = partial(power, exponent=2)
cube   = partial(power, exponent=3)
print(square(5))  # 25
print(cube(3))    # 27

Function composition: h(x) = f(g(x)) — applying g first, then f.

---

PAPER 2 — Computer Systems

8. CPU and Von Neumann Architecture

(See Paper 1 for FDE cycle and registers — same content applies.)

Additional A Level content:

Pipelining: fetch the next instruction while executing the current one. Increases throughput. Problems:

• Data hazard: instruction needs result from previous instruction not yet complete
• Control hazard: branch instruction — don’t know which instruction to fetch next
• Structural hazard: two instructions need the same hardware unit

CISC vs RISC:

	CISC	RISC
Example	Intel x86 (PC)	ARM (mobile, Apple Silicon)
Instruction set	Large, complex	Small, simple
Instruction size	Variable	Fixed (one clock cycle)
Memory access	Many instructions	Only load/store access memory
Registers	Fewer	More

---

9. Memory and Storage

Same as GCSE but with additional detail:

Cache coherence: in multi-core systems, each core has its own cache. When one core writes to memory, other cores’ caches become stale. Coherence protocols (like MESI) keep caches in sync.

Memory management techniques:

• Paging: memory divided into fixed-size pages; virtual → physical address mapping
• Segmentation: divided into variable-size segments (code, stack, heap)
• TLB (Translation Lookaside Buffer): cache for virtual→physical translations

---

10. Communication Systems (Networks)

Additional A Level networking content:

Circuit switching vs packet switching:

• Circuit switching: dedicated connection reserved for duration of communication (PSTN telephone)
• Packet switching: data split into packets, each routed independently; more efficient, resilient

Routers use routing tables to forward packets. Routing protocols (OSPF, BGP) maintain these tables.

Wireless networking:

• CSMA/CA (Collision Avoidance) — used in Wi-Fi; listens before transmitting; uses random back-off if channel busy
• CSMA/CD (Collision Detection) — used in wired Ethernet; detects collisions and retransmits

Encryption:

• Symmetric: one key for both encryption and decryption (AES). Fast but key distribution is a problem.
• Asymmetric: public key encrypts; private key decrypts (RSA). Solves key distribution. Slower.
• Digital signatures: sign with private key, verify with public key — proves authenticity and non-repudiation
• TLS/HTTPS: uses asymmetric encryption to exchange a symmetric session key; subsequent data encrypted with symmetric key

---

11. Databases

Relational databases:

• Data stored in tables (relations)
• Each row is a record/tuple
• Each column is an attribute/field
• Primary key — unique identifier per row
• Foreign key — references primary key of another table

Normalisation removes redundancy and anomalies:

• 1NF — atomic values; no repeating groups
• 2NF — 1NF + no partial dependency (non-key attributes depend on whole key)
• 3NF — 2NF + no transitive dependency (non-key attributes don’t depend on other non-keys)

SQL — key commands:

-- Select with filter
SELECT first_name, last_name, grade
FROM Students
WHERE grade >= 70
ORDER BY last_name ASC;

-- Join two tables
SELECT Students.name, Courses.title
FROM Students
INNER JOIN Enrollments ON Students.id = Enrollments.student_id
INNER JOIN Courses ON Enrollments.course_id = Courses.id;

-- Aggregation
SELECT department, COUNT(*) AS staff_count, AVG(salary) AS avg_salary
FROM Employees
GROUP BY department
HAVING AVG(salary) > 30000;

-- Insert, update, delete
INSERT INTO Students (name, grade) VALUES ('Alice', 85);
UPDATE Students SET grade = 90 WHERE name = 'Alice';
DELETE FROM Students WHERE name = 'Bob';

ACID properties (transactions must be):

• Atomic — all or nothing; no partial transactions
• Consistent — database remains valid before and after
• Isolated — concurrent transactions don’t interfere with each other
• Durable — committed changes survive crashes

---

12. Software Development

Development methodologies:

Methodology	Description	Best for
Waterfall	Sequential phases; requirements fixed upfront	Well-defined, stable requirements
Agile	Iterative sprints; requirements evolve	Fast-changing requirements
Spiral	Risk-driven iterations	High-risk projects
RAD	Rapid prototyping	Quick turnaround needed

Testing types:

• White box testing — tests internal logic; tester has access to source code
• Black box testing — tests functionality without knowing internal structure
• Alpha testing — tested by developers internally
• Beta testing — tested by a limited group of real users

---

13. Ethical, Legal, Cultural and Environmental Issues

Legislation:

Act	Key Provisions
Computer Misuse Act 1990	Criminalises unauthorised access and modification of computer material
Data Protection Act 2018 (UK GDPR)	Rights of data subjects; lawful basis for processing; data minimisation
Investigatory Powers Act 2016	Authorises government bulk data collection; oversight requirements
Copyright, Designs and Patents Act 1988	Protects software and digital content; illegal to copy without licence

Ethical frameworks:

• Utilitarian: maximise overall happiness — judge by consequences
• Deontological (Kantian): some actions intrinsically right or wrong regardless of outcome
• Virtue ethics: what would a person of good character do?

Topics that appear every year:

AI ethics: training data bias leading to discriminatory outcomes; accountability when AI causes harm; transparency and explainability; autonomous weapons.

Surveillance and privacy: CCTV, smart devices, location tracking. Benefits (crime prevention, safety) vs harms (chilling effect on behaviour, data breaches, authoritarian misuse).

Digital divide: unequal access based on income, geography, age, disability. Worsens existing inequality.

Environmental impact: data centres consume approximately 1-2% of global electricity; cooling uses vast amounts of water; manufacturing semiconductors is resource-intensive; e-waste from discarded devices leaches toxic chemicals.

Intellectual property: open source vs proprietary; Creative Commons licences; software piracy.

---

Extended answer technique

For 6–9 mark extended questions, use this structure:

1. Make a claim (“One advantage is…”)
2. Explain the claim (“This means that…”)
3. Give evidence/example (“For instance, …”)
4. Counter-argument (“However, one disadvantage is…”)
5. Conclusion (“Overall, the benefits outweigh the risks because…”)

Good luck! Practice past AQA 7517 papers and use the Question Bank on CompSci Tutoring for topic-by-topic drill questions with instant AI marking.