You are viewing a free preview of this lesson.
Subscribe to unlock all 4 lessons in this course and every other course on LearningBro.
Before you can excel in A-Level Computer Science, you need to understand exactly what the AQA exams look like. This lesson breaks down both papers and the NEA, the question types you will face, the command words AQA uses, the assessment objectives your answers are marked against, and how marks are distributed across the specification. Knowing the structure is the single most efficient piece of exam preparation you can do: it costs you one focused study session and it pays back across every question in both papers. A student who understands precisely what a "discuss" question demands, how many minutes a 12-mark answer deserves, and which assessment objective a code-writing task targets, makes fewer unforced errors than a student who is technically stronger but reads the paper blind. Every mark matters — and this lesson is the strategic foundation the other three build on.
This lesson is a meta-skill: it does not teach a single specification topic, but it equips you to attack every topic effectively under exam conditions. The structural knowledge here applies as follows:
In short, this lesson targets your examination performance across all of 4.1–4.13, rather than any one content area.
AQA A-Level Computer Science (specification 7517) is assessed through two written/on-screen exams and a non-exam assessment (NEA). Unlike many other A-Level subjects, Computer Science includes a significant practical programming component that is assessed through the NEA rather than in a traditional exam setting.
| Feature | Detail |
|---|---|
| Total marks | 275 (100 Paper 1 + 100 Paper 2 + 75 NEA) |
| Total exam time | 5 hours (2 hours 30 minutes per paper) |
| Grading | A*–E |
| Tiers | There is no tiering — all students sit the same papers |
| NEA | Programming project worth 75 marks (20% of A-Level) |
Key Point: The two exams account for 80% of your A-Level grade. The NEA accounts for the remaining 20%. While the NEA is important, the exams are where the majority of your marks come from — and where exam technique makes the biggest difference.
Paper 1 is worth 100 marks and lasts 2 hours 30 minutes. It accounts for 40% of your A-Level. This paper is taken on a computer rather than on paper, which is unique among A-Level subjects.
| Feature | Detail |
|---|---|
| Format | On-screen exam (completed on a computer) |
| Duration | 2 hours 30 minutes |
| Marks | 100 |
| Weighting | 40% of A-Level |
| Content tested | Sections 4.1–4.7 of the specification |
| Focus | Computational thinking, programming skill, theoretical knowledge |
The on-screen format means you type your answers into a computer-based exam system. For programming questions, you will write code directly into an editor. For short-answer and medium-answer questions, you type your responses into text boxes. You should be comfortable typing at reasonable speed and accuracy — practising typing code under exam conditions is essential preparation.
Exam Tip: You cannot use an IDE with auto-complete, syntax highlighting, or a compiler/interpreter during the on-screen exam. The editor is basic. You must be able to write correct code from memory without relying on IDE features.
Paper 1 tests the following sections of the AQA specification:
| Section | Topic | Key Areas |
|---|---|---|
| 4.1 | Fundamentals of programming | Data types, programming concepts, arithmetic operations, relational operations, Boolean operations, constants and variables, string handling, exception handling, subroutines, parameters, scope, recursion, OOP, file handling |
| 4.2 | Fundamentals of data structures | Arrays, records, stacks, queues, linked lists, trees, hash tables, dictionaries, vectors |
| 4.3 | Fundamentals of algorithms | Graph and tree traversals, Dijkstra's algorithm, searching algorithms (linear, binary), sorting algorithms (bubble, merge), optimisation algorithms |
| 4.4 | Theory of computation | Abstraction, automation, finite state machines, Turing machines, regular expressions, context-free languages, classification of algorithms (Big O), limits of computation (halting problem) |
| 4.5 | Fundamentals of data representation | Number systems (binary, hex, denary), binary arithmetic, floating-point representation, bit manipulation, character encoding (ASCII, Unicode), analogue/digital conversion, compression |
| 4.6 | Fundamentals of computer systems | Hardware, software, classification of programming languages, types of translators, Boolean algebra, logic gates |
| 4.7 | Fundamentals of computer organisation and architecture | Von Neumann architecture, Harvard architecture, registers, instruction set, assembly language, I/O, interrupts, processors, GPUs |
Paper 1 includes a mix of question types:
| Question Type | Typical Marks | What It Requires |
|---|---|---|
| Short answer | 1–4 marks | Define a term, state a fact, give an example, complete a calculation |
| Medium answer | 4–9 marks | Explain a concept, describe a process, compare approaches, work through an algorithm |
| Code-tracing | 4–8 marks | Follow code line by line using a trace table, determine the output |
| Code-writing | 5–15 marks | Write a function, subroutine, or algorithm in code or pseudo-code |
| Algorithm design | 5–12 marks | Design a solution to a problem, write pseudo-code, explain your approach |
Exam Tip: Code-tracing and code-writing questions together typically account for 30–40% of Paper 1 marks. Practising these question types under timed conditions is essential.
With 100 marks in 150 minutes, you have approximately 1.5 minutes per mark. Use this as a guide:
| Marks | Suggested Time |
|---|---|
| 1–2 marks | 2–3 minutes |
| 3–5 marks | 5–8 minutes |
| 6–9 marks | 9–14 minutes |
| 10–15 marks | 15–23 minutes |
Exam Tip: Leave 10 minutes at the end to review your answers. In an on-screen exam, it is easy to miss questions or leave incomplete answers. Use the review feature to check you have attempted every question.
Paper 2 is worth 100 marks and lasts 2 hours 30 minutes. It accounts for 40% of your A-Level. Unlike Paper 1, this is a traditional written exam where you write your answers on paper.
| Feature | Detail |
|---|---|
| Format | Written exam (pen and paper) |
| Duration | 2 hours 30 minutes |
| Marks | 100 |
| Weighting | 40% of A-Level |
| Content tested | Sections 4.1–4.12 of the specification (the entire specification) |
| Special feature | Section C uses Preliminary Material released in advance |
Paper 2 is divided into three sections:
| Section | Description | Marks | Content |
|---|---|---|---|
| Section A | Compulsory short and medium answer questions | Approximately 40 marks | Any topic from 4.1–4.12 |
| Section B | Compulsory short and medium answer questions | Approximately 30 marks | Any topic from 4.1–4.12 |
| Section C | Questions based on Preliminary Material | Approximately 30 marks | Scenario-based questions applying CS concepts |
Paper 2 can test everything from Paper 1 (sections 4.1–4.7) plus the following additional sections:
| Section | Topic | Key Areas |
|---|---|---|
| 4.8 | Consequences of uses of computing | Moral, ethical, legal, and cultural issues; privacy; censorship; ownership of information; legislation (Data Protection Act, Computer Misuse Act, Copyright Design and Patents Act, Regulation of Investigatory Powers Act) |
| 4.9 | Fundamentals of communication and networking | Communication methods, network topology, protocols, TCP/IP, the internet, firewalls, encryption, client-server and peer-to-peer models |
| 4.10 | Fundamentals of databases | Relational databases, entity-relationship modelling, normalisation (1NF, 2NF, 3NF), SQL, transaction processing, ACID |
| 4.11 | Big Data | Volume, velocity, variety, veracity; machine learning; graph and social network analysis; MapReduce |
| 4.12 | Fundamentals of functional programming | Function type, first-class objects, function application, partial function application, composition of functions, higher-order functions (map, filter, fold/reduce), list processing |
| Question Type | Typical Marks | What It Requires |
|---|---|---|
| Short answer | 1–4 marks | Define a term, state a fact, give an example, perform a calculation |
| Medium answer | 4–9 marks | Explain a concept, describe a process, compare approaches |
| Extended answer | 8–12 marks | Discuss, evaluate, or analyse a topic in depth with technical detail |
| Scenario-based (Section C) | 5–15 marks | Apply CS concepts to the Preliminary Material scenario |
Exam Tip: Paper 2 tests the entire specification (4.1–4.12), not just sections 4.8–4.12. Questions on programming, data structures, and algorithms can appear on both papers. Do not assume Paper 2 is only about theory.
The Preliminary Material is a scenario released by AQA in advance of the exam (typically several months before). It describes a real-world computing problem or system. Section C of Paper 2 asks questions about this scenario, requiring you to apply your CS knowledge to the specific context described.
| Feature | Detail |
|---|---|
| When released | Several months before the exam |
| What it contains | A description of a computing scenario, problem, or system |
| How many marks | Approximately 30 marks (Section C) |
| What you should do | Study it thoroughly, annotate it, prepare notes on which CS concepts apply |
Key Point: The Preliminary Material is not a secret — it is released publicly. You should study it extensively before the exam. Make notes on how different CS concepts (databases, networking, algorithms, ethical issues) relate to the scenario. However, the specific questions are not known until you open the exam paper.
The NEA is a programming project worth 75 marks and accounting for 20% of your A-Level. It is internally assessed by your teacher and externally moderated by AQA.
| Section | What It Assesses | Marks |
|---|---|---|
| Analysis | Understanding and defining the problem | 9 marks |
| Documented design | Designing a solution — data structures, algorithms, interfaces | 12 marks |
| Technical solution | The actual coded solution | 30 marks |
| Testing | Evidence of systematic testing | 12 marks |
| Evaluation | Evaluating the solution against requirements | 12 marks |
Exam Tip: The NEA is not an "easy 20%" — it requires sustained effort over several months. Start early, document as you go, and ensure your project is complex enough to demonstrate higher-level programming skills.
AQA uses specific command words in exam questions. Understanding exactly what each word requires is critical.
| Command Word | What It Means | Common Mistake |
|---|---|---|
| State | Give a brief, factual answer — no explanation needed | Over-explaining when a single sentence will do |
| Define | Give the precise meaning of a technical term | Giving a vague or incomplete definition |
| Describe | Give an account of the main features or characteristics | Adding evaluation when only description is needed |
| Explain | Give reasons — say why or how something works | Just describing without explaining the reasoning |
| Compare | Identify similarities and/or differences between two things | Only describing one side without making explicit comparisons |
| Discuss | Explore a topic by considering different perspectives, advantages, and disadvantages | Only presenting one viewpoint without considering alternatives |
| Evaluate | Make a judgement based on evidence, considering strengths and weaknesses | Describing without reaching a conclusion or judgement |
| Write a program / function | Produce working code or pseudo-code | Writing vague descriptions instead of actual code |
| Trace | Follow the execution of code step by step and show the values of variables | Skipping steps or not showing every variable change |
| Complete | Fill in missing parts of code, a table, or a diagram | Changing parts that are already provided instead of completing the gaps |
Reading the command word is not enough — you must let it dictate the shape of your answer. Work through these drills, each based on the same underlying topic (the program counter), to see how the command word changes everything.
Drill 1 — "State the purpose of the Program Counter (PC)." (1 mark) A single clause is all that is required: "It holds the address of the next instruction to be fetched." Writing three sentences here wastes time you need elsewhere and earns no extra credit. The command word "state" signals a one-mark factual response.
Drill 2 — "Explain how the Program Counter is used during the fetch phase of the fetch-decode-execute cycle." (3 marks) Now "explain" demands the mechanism and the why/how, so chain the reasoning: "The contents of the PC are copied into the Memory Address Register so the correct memory location is addressed (1). The PC is then incremented so that it points to the following instruction (1). This ensures the processor fetches instructions sequentially unless a jump alters the PC (1)." Three linked points, three marks.
Drill 3 — "Discuss the advantages and disadvantages of increasing clock speed to improve processor performance." (9 marks) "Discuss" requires multiple perspectives and balance. A one-sided answer ("a faster clock runs more cycles per second") caps at Level 1. You must weigh benefits (more fetch-execute cycles per second, faster throughput for serial workloads) against drawbacks (greater heat dissipation, higher power draw, diminishing returns versus adding cores, the memory wall) and reach a reasoned position. The command word, not the topic, is what pushes this into levels-of-response territory.
Drill 4 — "Evaluate whether a multi-core processor is the most appropriate way to improve performance for a heavily parallel image-processing task." (9 marks) "Evaluate" goes one step beyond "discuss": after weighing the options you must commit to a judgement. Here the parallel nature of the workload makes multi-core (or even GPU) genuinely suitable, and a top answer says so explicitly and justifies it, rather than trailing off after listing points.
Exam Tip: Highlight or underline the command word the instant you read a question, then ask "what verb is the examiner asking me to perform?" If the verb is state/define, write the minimum. If it is explain, give reasoned mechanism. If it is discuss/evaluate, build a two-sided argument with a conclusion. Mismatching your answer to the command word is one of the most common and most avoidable ways to lose marks.
AQA marks your answers against three Assessment Objectives (AOs). Different question types target different AOs.
| AO | What It Tests | Weighting | Which Questions |
|---|---|---|---|
| AO1 | Demonstrate knowledge and understanding of the principles and concepts of computer science, including abstraction, logic, algorithms, data representation, computer systems, networking, databases, and the consequences of computing | 30–35% | Short-answer definitions, descriptions, factual recall questions |
| AO2 | Apply knowledge and understanding of the principles and concepts of computer science, including to analyse problems in computational terms | 30–35% | Code-writing, algorithm design, applying concepts to scenarios, calculations |
| AO3 | Design, program, and evaluate computer systems that solve problems, making reasoned judgements about design decisions and trade-offs | 30–35% | Extended-answer discussions, evaluation questions, code design, Section C scenario questions, NEA |
Key Point: Notice that AO1 (knowledge recall) accounts for only about one-third of the marks. The majority of marks require you to apply knowledge (AO2) or design and evaluate solutions (AO3). This means rote memorisation alone is not sufficient — you must practise applying concepts and making reasoned judgements.
| Question Type | Primary AO | Example |
|---|---|---|
| "State the purpose of..." | AO1 | "State the purpose of the program counter register." |
| "Explain how a stack is used to..." | AO1 + AO2 | "Explain how a stack is used to handle subroutine calls." |
| "Write a function that..." | AO2 | "Write a function that takes a list of integers and returns the median." |
| "Trace the following algorithm..." | AO2 | "Trace the algorithm and show the contents of the array after each pass." |
| "Discuss the advantages and disadvantages of..." | AO3 | "Discuss the advantages and disadvantages of normalising this database to 3NF." |
| "Evaluate the suitability of..." | AO3 | "Evaluate the suitability of using a client-server model for this scenario." |
Understanding how marks are distributed helps you allocate revision time effectively.
| Component | Marks | Weighting | Content |
|---|---|---|---|
| Paper 1 | 100 | 40% | Sections 4.1–4.7 (programming, data structures, algorithms, computation theory, data representation, computer systems, architecture) |
| Paper 2 | 100 | 40% | Sections 4.1–4.12 (all content, including networking, databases, Big Data, functional programming, ethics/legislation) |
| NEA | 75 | 20% | Practical programming project |
Based on past paper analysis, the following topics typically carry the most marks:
| Topic Area | Approximate % of Exam Marks | Priority |
|---|---|---|
| Programming and algorithms (4.1, 4.3) | 25–30% | Very High |
| Data structures (4.2) | 10–15% | High |
| Theory of computation (4.4) | 8–12% | High |
| Data representation (4.5) | 8–12% | High |
| Computer systems and architecture (4.6, 4.7) | 8–12% | Medium-High |
| Networking (4.9) | 6–10% | Medium |
| Databases (4.10) | 6–10% | Medium |
| Consequences of computing (4.8) | 4–8% | Medium |
| Big Data (4.11) | 3–5% | Medium |
| Functional programming (4.12) | 5–8% | Medium-High |
Key Point: Programming and algorithms consistently carry the highest proportion of marks. If you are strong at coding and algorithmic thinking, you have a significant advantage. If you are weak in these areas, targeted practice is essential.
Structural knowledge is genuinely synoptic — it ties the whole qualification together rather than sitting in one corner of it.
| Misconception | Reality |
|---|---|
| "Paper 2 is only theory — no programming." | Paper 2 covers the whole specification 4.1–4.13, including programming, data structures and algorithms. Code can and does appear on Paper 2. |
| "The NEA is an easy 20% I can leave until later." | The NEA needs sustained work over months; a rushed or trivial project is capped in the higher bands. The technical-solution area alone is the most heavily weighted single component of the project. |
| "Memorising definitions is enough to do well." | AO1 recall is only about a third of the marks. The majority require AO2 application and AO3 design/evaluation, which rote learning cannot deliver. |
| "All command words basically mean 'write what you know'." | Each command word demands a specific response shape. Answering an "evaluate" question with pure description caps you at the lowest level regardless of how much you write. |
| "On-screen Paper 1 is just like coding at home." | The on-screen environment is deliberately basic — no auto-complete, no syntax highlighting and limited or no execution. You must write correct code from memory and check it by eye. |
| "The Preliminary Material is secret until the exam." | It is released publicly in advance precisely so you can study and annotate it. Engaging with it early is one of the biggest easy wins available. |
| "Longer answers always score higher." | Examiners reward developed, relevant points, not word count. A focused 9-mark answer with four well-linked points beats a rambling page that never reaches a conclusion. |
AQA-style question. A college is choosing how to assess its new Computer Science cohort and a teacher claims: "Since Paper 1 and Paper 2 are each worth 40%, while the NEA is worth only 20%, students should spend almost all of their independent study time on past exam papers and very little on the project."
Discuss the extent to which this claim represents a sensible revision and preparation strategy for the AQA A-Level Computer Science qualification. (9 marks)
AO breakdown:
The claim is partly right because the two papers together are worth 80% of the A-Level, so students do need to do a lot of exam practice. Paper 1 is on-screen and Paper 2 is written, and both test programming and theory. The NEA is only 20% so it is less important than the exams. Therefore students should spend most of their time on past papers, but they should still do some work on the project so they do not fail it. Overall the teacher is mostly correct because 80% is more than 20%.
Examiner-style commentary: This response shows accurate AO1 knowledge (correct weightings, on-screen vs written) and makes a genuine attempt at AO2 by linking the structure to time allocation. However, the AO3 evaluation is thin: it treats the decision as a simple 80-versus-20 comparison and does not consider that the NEA must be completed during the course (it cannot be crammed), that the skills overlap, or that 20% is the difference between many grade boundaries. The conclusion restates the premise rather than weighing it. This sits in the middle band.
The teacher is correct that the two written and on-screen papers dominate the grade: at 40% each they total 80%, against 20% for the NEA, so heavy past-paper practice is clearly justified, especially for the code-tracing and extended-answer techniques that distinguish strong scripts. However, the claim that students should do "very little" on the project is questionable. The NEA cannot be revised for in a final push the way exam content can; it is coursework that must be developed steadily over months, so neglecting it early risks a weak technical solution that is then capped in the higher bands. There is also significant overlap: building a substantial project strengthens exactly the OOP, file-handling and algorithm skills that Paper 1 rewards, so project time is not wasted exam time. On balance, the teacher is right to prioritise exam practice but wrong to dismiss the project; a sensible strategy front-loads steady NEA work alongside, not instead of, growing exam practice.
Examiner-style commentary: This answer reaches the top band. The AO1 knowledge is precise and the AO2 application is sustained throughout. Crucially it delivers genuine AO3: it identifies that the NEA's coursework nature makes "leave it until later" a false economy, recognises the skills overlap, and reaches a balanced, justified conclusion that does more than echo the premise. The two-sided structure and clear final judgement are exactly what a "discuss" command word rewards.
At first glance the teacher's arithmetic is sound — Paper 1 and Paper 2 are each weighted at 40% and the NEA at 20%, so the examined components carry four-fifths of the marks and deserve the larger share of revision effort, particularly for high-leverage exam techniques such as trace tables, recursion and levels-of-response extended answers. Yet treating the three components as interchangeable blocks of "study time" misreads how each is assessed. The NEA is internally assessed coursework developed across the course; its analysis, design, technical-solution, testing and evaluation areas are built incrementally and cannot be recovered by last-minute effort, so deprioritising it early is precisely the wrong moment to do so. Moreover the components are not independent: the project's technical solution exercises the same object-oriented design, data structures and algorithms that Paper 1 code-writing questions demand, so disciplined project work is partly a form of exam preparation. Finally, in a qualification graded across fine boundaries, 20% is rarely "negligible" — it can move a candidate a full grade. The most defensible strategy therefore rejects the binary the teacher implies: maintain steady, well-documented NEA progress throughout the course while progressively increasing timed past-paper practice as the exams approach, so that the 80% and the 20% reinforce rather than compete with one another. The teacher's instinct to prioritise the exams is reasonable; the advice to do "very little" on the project is not.
Examiner-style commentary: A comprehensive top-band answer. It opens by conceding the valid part of the claim (showing balance immediately), then dismantles the flawed part with three distinct, well-developed strands — the coursework nature of the NEA, the skills overlap, and the grade-boundary significance of 20% — before landing a nuanced conclusion that explicitly rejects the false binary. Technical vocabulary is accurate and the structure (concede, analyse, judge) models exactly how to attack a "discuss" command word for full marks.
Once you are comfortable with the structure, push into the finer strategy that separates strong candidates from average ones.
| Key Takeaway | Detail |
|---|---|
| Two exams + NEA | Paper 1 (on-screen, 40%), Paper 2 (written, 40%), NEA (programming project, 20%) |
| Paper 1 focus | Computational thinking, programming, code tracing — sections 4.1–4.7 |
| Paper 2 focus | Broader theory plus Preliminary Material scenario — sections 4.1–4.13 |
| Preliminary Material | Released in advance for the relevant Section of Paper 2 — study it thoroughly |
| Assessment objectives | AO1 (knowledge ~33%), AO2 (application ~33%), AO3 (design/evaluation ~33%) |
| Command words | State, define, describe, explain, compare, discuss, evaluate, write, trace, complete |
| Match answer to command word | The verb dictates the shape — minimal for state, mechanism for explain, two-sided judgement for discuss/evaluate |
| Time per mark | Approximately 1.5 minutes per mark on both papers |
| Programming is key | 25–30% of exam marks relate directly to programming and algorithms |
Understanding the exam structure is your first strategic advantage. You now know exactly what each paper tests, how many marks each question type carries, how the command words dictate your answer shape, and how your answers will be assessed against the three AOs. Use this knowledge to focus your revision and practise the right skills.
This content is aligned with the AQA A-Level Computer Science (7517) specification.