AQA AS-Level · Exam Tips

Computer Science 7516 Exam Tips

Aggregated exam tips, time management strategies, and common pitfalls for AQA AS Level Computer Science 7516, detailing the specific patterns and practical traps from recent exam series.

4 min readUpdated: Jun 21, 2026

Exam at a Glance

Papers
2
Total Marks
150
Time Limit
3h 15min
Question Types
7
PaperDurationMarksQuestionsWeightingQuestion Types
Paper 1: On-Screen Practical Programming1h 45min751850%Algorithm Tracing, Conceptual Short-Answer, Direct Coding Implementation, Identifier Identification, Explain Code Subroutines, Object Composition & OOP, Design Outline, Program Modification (Standard), Program Modification (Complex Parameter-passing), Subroutine Authoring and Integration
Paper 2: Written Theory1h 30min753150%Multiple Choice & Basic Representations, Binary Arithmetic & Conversions, Quantitative Hardware/Sound Calculations, Logic Circuit and Boolean Algebra, Processor & Stored Program Concepts, Assembly Language Program Writing, External Storage & Reading Technologies, Structured Evaluation Essay, Network Architecture & Protocols
Grade Scale
ABCDEU
Calculator Policy

A scientific or graphical calculator that meets JCQ regulations may be used (some GCSE Mathematics and Science papers are non-calculator). Graphical calculators must be set to exam mode; you must clear any stored programs, notes or data before the exam, and the calculator must not be able to retrieve stored text or formulae.

  • AO1: Recall, describe and explain common computer science concepts and principles. (35%)
  • AO2: Apply computer science knowledge and understanding to solve practical and theoretical problems. (35%)
  • AO3: Design, write, test and evaluate computer programs. (30%)

Built from real past papers and marking schemes (2022–2024).

Tips & Strategies

The On-Screen Practical: Mastering the Paper 1 Codebase

AQA AS Level Computer Science Paper 1 demands a unique blend of fast logical tracing and clean code modification under time pressure. Since you are given the Skeleton Program in advance, top-tier students study the code until they understand the data structure flow inside out. One of the biggest traps in Section C is attempting to use high-level, language-specific built-in array methods (such as .pop(), .insert(), or .remove() in Python) to delete or insert instructions. The exam explicitly requires you to perform programmatic shifts within fixed-size simulated arrays. If you use a built-in shortcut, you risk losing both method and accuracy marks.

Furthermore, whenever you are instructed to insert or delete elements in the skeleton's array structures, you must remember to modify the tracked element count (usually stored in index 0 of the program data array). Forgetting to increment or decrement this count is a primary cause of off-by-one runtime crashes during grading. Always make sure to write logic that protects parallel arrays from getting out of sync or throwing index-out-of-bounds exceptions when clearing or moving entries.

The 5-Minute Habit that Saves a Grade: Tracing Without Duplication

In Section A, trace tables are highly weighted, but many students leak easy marks because of formatting errors. Examiners state that writing duplicated or persistent values in trace table columns where empty blank rows are expected violates explicit instruction guidelines. When hand-tracing algorithms (such as sorting or binary arithmetic logic), only write a new value in a column when that specific variable's value actually changes. If a loop iterates and a variable remains unchanged, leave its cell blank. This clean representation prevents confusion and aligns directly with the official mark schemes.

Where the Marks Really Hide: Showing Boolean and Binary Working

In Paper 2, quantitative and logical units can make or break your grade. For Boolean algebra simplifications, never jump directly to the final identity. Marks are distributed generously for showing every single intermediate step, such as applying De Morgan's Law, distributing terms, or extracting common factors. For example, if you are simplifying \( \overline{W \cdot X \cdot Z} + W \cdot Z \), document each rule you apply. If your final identity is incorrect but your step-by-step logic is clean, you can still secure up to 3 out of 4 working marks.

A similar rule applies to binary addition and subtraction. When adding two binary numbers, you must show the carry row explicitly. If the carry bits are missing, you will drop method marks. For binary subtraction, never subtract directly in binary, and never convert to decimal to work out the answer before converting back. Instead, convert the subtrahend into its two's complement form and add it to the first number, documenting every column carry as proof of binary addition.

Cracking the Assembly Code: Registers and Branches

Assembly language questions in Paper 2 represent a concentrated block of programming marks. Many candidates struggle with comparing and branching because they write commands on memory labels directly. Remember that AQA assembly requires you to load value patterns into registers using LDR or copy immediate values with MOV before any comparison (CMP) can occur. Always trace your branching targets: if your condition is met, ensure your branch instruction (like BGT, BLT, or BEQ) jumps to the correct label, and structure your loops to terminate cleanly. Missing a termination jump can create infinite loops in your assembly code, causing a severe penalty.

Conquering the 12-Mark Essay: Hardware Meets Real-World Impact

The structured evaluation essay in Paper 2 assesses your ability to follow a line of reasoning on moral, ethical, legal, and cultural issues. High-scoring essays do not just list definitions; they weave technical properties of hardware directly into the social or legal context of the scenario. For instance, if you are discussing the use of solid-state drives (SSDs) in a location-tracking server, you must explicitly link physical SSD characteristics—such as fast read/write speeds, shock resistance (no moving parts), and write-limit wear—to the high-intensity data collection requirements of the tracking database. Address different societal perspectives, mention specific legislations like the GDPR or Computer Misuse Act, and draw a balanced, technical conclusion.

What Top Scorers Do Differently

  • Practice Validation Constraints: High achievers practice writing robust loops that check if user-defined index entries exceed the available bounds in parallel arrays.
  • Deconstruct Command Words: Pay careful attention to the differences between "State" (one-word/short answers), "Explain" (requires detailed reasoning), and "Describe" (requires a chronological step-by-step process).
  • Do Not Invent Hardware Capabilities: Avoid making incorrect technical claims. For example, never state that hexadecimal numbers take up less memory, or that passive RFID tags require batteries. Understand the physical constraints of passive inductive coupling and human-readable formatting.

Calculator Programs

Graph: zeros, intersections & turning points

Graphical calculator / GDC (exam mode)

Purpose: Plot a function to read its roots (zeros), points of intersection, and maxima/minima.

When to use it: Checking solutions, sketching, or solving where an analytic method is hard.

Steps
Graph the function(s) and use the built-in zero, intersect and maximum/minimum tools.

Exam note: Allowed under JCQ rules, but you must still show your method — an unsupported calculator answer earns no method marks. Clear all stored programs, notes and data (graphical calculators in exam mode) before the exam.

Numerical equation solver

Graphical calculator / GDC (exam mode)

Purpose: Solve an equation or find a variable numerically when an algebraic route is long or implicit.

When to use it: Iterative or implicit equations, or to confirm an algebraic solution.

Steps
Use the equation/zero solver, entering the equation and a sensible starting estimate.

Exam note: Allowed under JCQ rules, but you must still show your method — an unsupported calculator answer earns no method marks. Clear all stored programs, notes and data (graphical calculators in exam mode) before the exam.

Numerical integration & differentiation

Graphical calculator / GDC (exam mode)

Purpose: Evaluate a definite integral \(\int_a^b f(x)\,dx\) or a gradient \(f'(x)\) at a point.

When to use it: Checking calculus answers, or where only a numerical value is needed.

Steps
Use the GDC's numeric integral / derivative function with the limits or the point.

Exam note: Allowed under JCQ rules, but you must still show your method — an unsupported calculator answer earns no method marks. Clear all stored programs, notes and data (graphical calculators in exam mode) before the exam.

Statistics & probability distributions

Graphical calculator / GDC (exam mode)

Purpose: 1-var/2-var statistics, linear regression, and cumulative binomial / normal / Poisson probabilities without tables.

When to use it: Statistics questions and hypothesis tests.

Steps
Enter data in the statistics editor, or use the distribution menu (binomial cdf, normal cdf, …).

Exam note: Allowed under JCQ rules, but you must still show your method — an unsupported calculator answer earns no method marks. Clear all stored programs, notes and data (graphical calculators in exam mode) before the exam.

Common Mistakes

  1. 1highMarks at stake: 5Programming (Fundamentals of programming)

    Attempting to write persistent or duplicated values in trace tables where empty cells are expected.

    How to avoid it: Only write values in a column when the variable actually changes value. Keep rows blank if variables are not updated.
  2. 2highMarks at stake: 12Data structures and abstract data types

    Using high-level built-in collection methods (e.g. .pop(), .insert(), .remove() in Python) to delete/insert elements in arrays.

    How to avoid it: Manually shift array elements inside a fixed-size array structure using loops as requested in the program skeleton guidelines.
  3. 3highMarks at stake: 2Binary number system

    Subtracting binary numbers directly in binary or converting via decimal representation without showing binary two's complement conversion.

    How to avoid it: Convert the subtrahend into a two's complement bit pattern first, then show the carry-based binary addition clearly.
  4. 4highMarks at stake: 4Programming (Fundamentals of programming)

    Forgetting to update index 0 of the program data array (the tracked list length) after executing line deletions or insertions.

    How to avoid it: Always decrement or increment the integer representing the count in the first cell of the parallel/source code data structure when structure size changes.
  5. 5mediumMarks at stake: 1Number bases

    Believing that hexadecimal formats use less physical storage space in computer systems memory.

    How to avoid it: Hexadecimal is strictly an abstraction tool for humans to read and write binary representations easily; the data occupies identical memory space.
  6. 6highMarks at stake: 1Binary number system

    Omitting the carry row bits during binary addition steps on Paper 2.

    How to avoid it: Draw a clear carry row just below your operands to show carry bits that carry over to consecutive columns.
  7. 7mediumMarks at stake: 2Networking

    Assuming that a physical star network topology acts as a logical star topology by default.

    How to avoid it: Note that while devices physically wire to a central point, if that central device is a hub rather than a switch, it transmits packets to all nodes logically.

Turn these tips into top grades

thinka turns your weak spots into targeted practice, with instant marking and exam-style feedback. Study smarter, not longer.

Practise real exam questions with instant AI feedback and marking.

Start Practising Free