How to revise for A-level Computer Science (AQA)

A-level Computer Science catches out students who revise it like one subject, because it is really three: the theory you memorise, the programming you have to be fluent in, and the maths of computation that feels more like further maths than coding. Revise all three the same way and one of them always lets you down. Split them up and it becomes one of the more predictable A-levels, because so much of it rewards practice rather than luck.

This guide is written around AQA’s 7517 specification. It covers what the two papers and the coding project test, the topics students lose marks on, how to get fluent for the on-screen programming exam, and a weekly plan you can start this week.

What AQA 7517 tests

Two exams worth 40% each and a coding project worth 20%. Knowing which paper a topic belongs to tells you how to revise it.

• Paper 1 (on-screen, 40%): programming, data structures, algorithms and the theory of computation, sat on a computer, usually with a pre-released skeleton program. This is mostly applied: writing, correcting and tracing code.
• Paper 2 (written, 40%): data representation, computer systems and architecture, networking, databases, big data, functional programming and the consequences of computing. This is mostly recall and explanation.
• NEA (20%): a substantial coding project you build, test and document.

The single most useful early move is to sort every topic into “write code” (Paper 1) or “learn and explain” (Paper 2), because they need completely different revision.

The topics that lose the most marks

A handful of topics decide grades year after year. Prioritise these.

Subroutines, scope and recursion. One of the most common exam areas. Know parameters, the difference between local and global scope, and how recursion uses the call stack. Trace a few recursive examples by hand until the stack behaviour is obvious.

Algorithms and complexity. Be able to trace and compare the sorts (bubble, merge, insertion) and searches (linear, binary), and state their best, worst and average time complexity in Big-O. Graph and tree algorithms, especially Dijkstra’s shortest path and traversals, are high-value and very learnable by hand.

Theory of computation. Finite state machines, regular expressions, Backus-Naur Form, Turing machines, and tractable versus intractable problems and the halting problem. Abstract, so learn the precise definitions and do lots of small worked examples.

Data representation. Two’s complement, and floating-point representation and normalisation, plus Reverse Polish Notation. These are pure practice: do a few conversions a day and they stop being scary.

Databases and networking. Normalisation to third normal form and SQL for Paper 2, and the TCP/IP stack, IP addressing and client-server models. Make a compact card for each definition, this is classic recall you can bank with flashcards.

The programming paper

Paper 1 is sat on a computer, so reading code is not enough, you have to write it fluently under time pressure. Two things build that:

• Get fluent in your language and the skeleton program. AQA releases a skeleton program before the exam. Work through it, understand every subroutine, and predict what the examiners are likely to ask you to extend.
• Trace code by hand. Build trace tables for loops, conditions and recursion until you can predict the output of a piece of code without running it. This is heavily examined and very learnable.

The coding project (NEA)

The non-exam assessment is 20% of your grade, and it is where students either bank marks steadily or lose them in a last-minute panic. Three rules save most of the pain:

• Start early and pick a solvable problem. An ambitious project you cannot finish scores worse than a focused one you complete and document well.
• Document as you go. Marks are spread across analysis, design, technical solution, testing and evaluation, so keep a running log of decisions and test evidence from day one.
• Test continuously. Screenshots and a clear test plan with results are easy marks that are painful to reconstruct at the end.

The method that actually works

Re-reading the textbook feels productive and does very little. Two techniques do the heavy lifting, and they map onto the two papers.

• Active recall for Paper 2. Close the notes and retrieve definitions and processes, networking, databases, computation, from memory. Good flashcards are ideal for the volume of precise terms.
• Spaced repetition so abstract theory learned early does not fade. Short, frequent reviews beat cramming, and here is why it works.
• Write and trace code, and do past papers for Paper 1 and the applied questions. Mark against the official mark scheme so you learn what earns marks, not just whether you were roughly right.

A weekly plan you can start now

• Daily (10–15 minutes): a few two’s-complement or floating-point conversions and one algorithm traced by hand.
• Two or three recall sessions: flashcards on a Paper 2 topic (networking one day, databases the next), reviewing older decks as they come due.
• One programming session: work on the skeleton program or a past Paper 1 question, writing real code.
• Steady NEA progress and a timed past-paper section each week, marked against the scheme, feeding your weak topics back into next week’s revision.

Resources

Revise from the official AQA 7517 specification and its past papers so you learn the right detail, and work through the released skeleton program early. Our own A-level Computer Science lessons break the demanding topics, from Dijkstra’s algorithm to the theory of computation, into short, testable chunks.

If you want practice on a specific topic, Aicademy can generate a lesson, a quiz and spaced-repetition flashcards on any part of the course, and its tutor can trace through an algorithm with you. It is free to start, so you can drill the exact topics that keep costing you marks. If you are also brushing up GCSE, see how to revise for GCSE Computer Science.