AQA GCSE Computer Science (8525) — The Complete 2024/25 Guide

AQA GCSE Computer Science (specification 8525) is the most widely taken Computer Science GCSE in England. This guide covers everything — spec structure, what each paper tests, how grades are awarded, common student mistakes, and the most effective revision strategies.

Specification overview

AQA 8525 is assessed across two written papers, each worth 50% of your final grade. There is no controlled assessment or coursework at GCSE level.

• Paper 1: Computational thinking and programming (1 hour 30 minutes, 80 marks)
• Paper 2: Computing concepts (1 hour 30 minutes, 80 marks)

Both papers are available in Python or a choice of other languages for the programming sections. The majority of students sit the Python option.

---

Paper 1: Computational thinking and programming

Paper 1 tests your ability to read, trace, write, and debug programs. It is the more practical of the two papers.

Topics covered

Section A — Programming

• Sequence, selection, and iteration
• Variables, constants, data types (integer, float, string, boolean, character)
• Input/output
• String operations: length, substring, concatenation, upper/lower case
• File handling: open, read, write, close
• Arrays (1D and 2D)
• Records and data structures
• Sub-programs (procedures and functions), parameters, local vs global variables
• Random number generation

Section B — Computational thinking

• Decomposition, abstraction, algorithmic thinking
• Structured diagrams and flowcharts
• Trace tables and dry runs
• Pattern recognition

Section C — Algorithms

• Linear and binary search
• Bubble sort and merge sort
• Time complexity (Big O is not required at GCSE, but O(n²) vs O(n log n) thinking is useful)

What the exam looks like

Paper 1 uses pseudo-code (AQA’s own format) and Python. Questions typically ask you to:

1. Trace a piece of code and fill in a trace table
2. Identify errors in a program (syntax vs runtime vs logic)
3. Write code to solve a given problem
4. Extend or modify existing code
5. Evaluate whether a solution is efficient or correct

A common question structure: a 2-mark “what does this code output?” followed by a 4-mark “write a function that…” and a 6-mark “write a program that…”

---

Paper 2: Computing concepts

Paper 2 covers the theory of computer science. No programming is required, but you must understand how concepts work at a technical level.

Topics covered

Component 1: Data representation

• Binary, denary, hexadecimal conversion
• Binary arithmetic (addition, overflow)
• Two’s complement for negative numbers
• Binary shifts (logical left and right)
• Units: bits, nibbles, bytes, KB, MB, GB, TB (1024-based)
• ASCII and Unicode
• Image representation: pixels, bit depth, resolution, colour depth
• Sound representation: sample rate, sample resolution, Nyquist theorem
• Data compression: lossy vs lossless, run-length encoding

Component 2: Computer systems

• The purpose and function of the CPU: fetch-decode-execute cycle
• CPU components: ALU, CU, cache, registers (PC, MAR, MDR, accumulator)
• Von Neumann vs Harvard architecture
• Primary storage: RAM and ROM
• Secondary storage: magnetic, solid-state, optical
• Embedded systems

Component 3: Computer networks and security

• Network types: LAN, WAN, MAN
• Network topologies: star, bus, ring, mesh
• How data is transmitted: protocols, packets, IP addresses, MAC addresses
• DNS, HTTP/HTTPS
• Network hardware: routers, switches, hubs, NICs
• The Internet: clients and servers, cloud computing
• Cyber security threats: malware types, phishing, denial of service attacks
• Countermeasures: firewalls, encryption, passwords, physical security

Component 4: Programming paradigms and data structures (brief coverage)

• Relational databases: tables, records, fields, primary/foreign keys, SQL basics
• Boolean logic and logic gates: AND, OR, NOT, NAND, NOR, XOR
• Truth tables and Boolean algebra

---

Grade boundaries and what they mean

AQA publishes grade boundaries after each exam series (typically in August). Boundaries vary by year depending on how difficult the papers were.

As a rough guide from recent years:

• Grade 9: typically around 80%+
• Grade 7: typically around 60–65%
• Grade 5 (strong pass): typically around 45–50%
• Grade 4 (standard pass): typically around 35–40%

These vary significantly year to year — a hard paper in 2023 had a Grade 5 boundary around 43%, while an easier paper in a previous year needed ~52% for a 5.

The most reliable way to understand boundaries is to do past papers under timed conditions and compare your raw mark to published boundaries from the same paper.

---

The most common mistakes in AQA 8525 exams

These are mistakes I see repeatedly as an examiner and tutor:

Paper 1 mistakes

1. Wrong data type in answers — using int when the question implies a decimal is needed, or not considering that a percentage should be a float
2. Off-by-one errors — especially in FOR loops and array indexing. AQA uses 0-indexed arrays
3. Not returning a value — writing a function but forgetting the RETURN statement
4. Global vs local confusion — declaring a variable inside a sub-program that’s needed outside it
5. Partial trace tables — students often get the first 2 rows right then stop or lose track of the loop counter

Paper 2 mistakes

1. Confusing lossy and lossless compression — remembering which is which, and which is used for what file type
2. Getting CPU components wrong — specifically confusing MAR and MDR
3. IP vs MAC addresses — mixing up their purposes (IP = logical address, routable; MAC = physical address, hardware)
4. SQL syntax errors — forgetting WHERE, using = vs ==, wrong capitalisation
5. Two’s complement sign extension — not recognising that the leftmost bit has a negative weight

---

How to revise for AQA 8525

For Paper 1 (Programming)

The most effective revision for Paper 1 is writing code, not reading about it.

1. Practice trace tables daily — pick any short Python program and trace it manually before running it
2. Write programs from scratch — don’t just modify examples. Take a problem (e.g., “write a login system with 3 attempts”) and build it
3. Do past paper Section C questions — these 8–12 mark questions are where marks are most lost
4. Debug intentionally broken code — AQA often gives broken code and asks you to fix it

For Paper 2 (Theory)

1. Use flashcards for definitions — you need to know definitions precisely (e.g., the difference between a switch and a hub)
2. Practice binary/hex calculations — these should be fast and automatic. Five minutes daily on conversion builds speed
3. Draw diagrams from memory — fetch-decode-execute cycle, star topology, logic gate circuits
4. Read mark schemes carefully — AQA often rewards specific technical language (e.g., “packets” not “data”)

Both papers

• Do timed past papers — 80 marks in 90 minutes = just over 1 minute per mark. Many students run out of time
• Read the question twice — “state” vs “explain” vs “describe” require different answer lengths
• Use the mark allocation as a guide — a 4-mark question needs at least 4 distinct points

---

Recommended revision timeline

Weeks before exam	Focus
10+ weeks	Cover all topics, take notes
6–9 weeks	Begin past papers; identify weak topics
4–5 weeks	Targeted revision on weak areas; daily practice problems
2–3 weeks	Full past papers under timed conditions
1 week	Light revision; review mark schemes; rest

---

Useful resources

• AQA specification: Download from aqa.org.uk — the specification is your Bible. Everything examinable is listed in it
• CompSci Tutoring question bank: 300+ AQA GCSE questions with mark schemes, filterable by topic
• Past papers: Available from AQA’s website (login required) and ExamPro for teachers
• Python documentation: Useful for Paper 1 string and file handling methods

---

A note on the pseudocode

AQA uses its own pseudocode format in Paper 1. This is NOT Python, but it’s very similar. Key differences:

# AQA pseudocode uses:
WHILE condition DO
  ...
ENDWHILE

FOR i ← 0 TO 9 DO
  ...
ENDFOR

IF condition THEN
  ...
ELSE
  ...
ENDIF

SUBROUTINE name(param)
  ...
ENDSUBROUTINE

# Arrays are declared:
names ← ['Alice', 'Bob', 'Charlie']
# Index from 0
PRINT(names[0])  # outputs Alice

Exam questions may present code in pseudocode, Python, or both. You should be comfortable reading both formats.

---

Good luck with your AQA GCSE Computer Science exam. If you’d like personalised help — whether with programming practice, exam technique, or specific topics — book a tutoring session or explore the free revision resources on this site.