AQA GCSE Computer Science (8525) was first examined in June 2022, since the 2020-taught cohort's original 2021 sitting was disrupted by the pandemic, so June 2022 is genuinely the first ever live sitting of this specification, not an artefact of our own search. We analysed every Paper 1 sitting we could obtain the real question paper and mark scheme for: June 2022 and June 2023 (the June 2024 and June 2025 papers exist but are not yet public on AQA's own filestore, which keeps live series behind a login wall for roughly two years after the exam). Paper 1 is entirely about computational thinking and programming: tracing algorithms represented in AQA pseudo-code or Python, writing and completing Python programs, spotting and fixing logic and syntax errors, and explaining core programming concepts. It does not test binary, hex, logic gates, networks or databases, those are all on Paper 2. Below is what each recurring question type has asked across the two sittings we have, with a complete worked answer written to the mark scheme for each one, every paragraph explained.
Questions © AQA, quoted for analysis. Pseudo-code and program code described in our own words, not reproduced verbatim. Mark scheme content translated into plain English, not copied. PrepWise is independent and not endorsed by AQA.
This appears at least twice in both June 2022 and June 2023, on a different algorithm each time: a REPEAT UNTIL subroutine and a bubble sort style array swap in June 2022, then a nested nested-loop indexing bug and a binary search in June 2023.
Trace a subroutine that repeatedly halves a number using integer (DIV) division, counting how many halvings it takes to bring the number down to 1 or less.
A subroutine called calculate, taking one parameter n, represented in pseudo-code. It sets a to n and b to 0, then repeats a block that integer-divides a by 2 (using the DIV operator, so remainders are discarded) and adds 1 to b, continuing this REPEAT UNTIL a is less than or equal to 1, then outputs b.
Starting values: n is 50, so a is set to 50 and b is set to 0. Because this is a REPEAT UNTIL loop, the body runs at least once before the condition a is less than or equal to 1 is ever checked.
Each pass integer-divides a by 2 and adds 1 to b: 50 DIV 2 is 25 with b now 1, 25 DIV 2 is 12 with b now 2, 12 DIV 2 is 6 with b now 3, 6 DIV 2 is 3 with b now 4, and 3 DIV 2 is 1 with b now 5. Once a reaches 1 the UNTIL a is less than or equal to 1 condition is true, so the loop stops and OUTPUT b produces 5.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise trace table questionsTrace a nested FOR loop over a three-element array that compares each pair of neighbouring elements and swaps them if they are in the wrong order, ending with the array sorted alphabetically.
An algorithm in pseudo-code that starts with a three-element array arr holding the characters 'c', 'b' and 'a' at indices 0, 1 and 2. A nested FOR loop (an outer loop for i from 0 to 1, an inner loop for j from 0 to 1) compares arr[j + 1] with arr[j], and if arr[j + 1] is alphabetically before arr[j] it swaps them using a temp variable.
The array starts as arr[0] = c, arr[1] = b, arr[2] = a, with i and j both starting at 0 on the first pass. On the first comparison (i = 0, j = 0) arr[1] (b) is alphabetically before arr[0] (c), so a swap happens: temp is set to c, arr[0] becomes b, and arr[1] becomes c, giving b, c, a.
On the next comparison (i = 0, j = 1) arr[2] (a) is alphabetically before arr[1] (c), so another swap happens: temp is set to c, arr[1] becomes a, and arr[2] becomes c, giving b, a, c. On the final comparison (i = 1, j = 0) arr[1] (a) is alphabetically before arr[0] (b), so a third swap happens: temp is set to b, arr[0] becomes a, and arr[1] becomes b, giving the final sorted array a, b, c. The last comparison (i = 1, j = 1) checks c against b and finds no swap is needed.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise trace table questionsTrace a nested loop over two arrays (names and scores) that is meant to display all three test scores for each of three students, but has a bug in the inner loop's bounds, and trace exactly what it actually outputs, bug and all.
An algorithm in pseudo-code with two arrays: names holding three student names, and scores holding nine test scores (three per student, in the same order as names). An outer FOR loop (i from 0 to 2) selects each student in turn, and an inner FOR loop (j from 0 to 1) is meant to display that student's scores, indexing into scores using the expression i times 3 plus j, and incrementing a counter each pass.
On the first student (i = 0, person = Natalie), the inner loop runs for j = 0 and j = 1: result is scores[0 times 3 plus 0] which is scores[0], 78, then scores[0 times 3 plus 1] which is scores[1], 81, with count showing 0 then 1 on each pass, since count is displayed before it increments.
The same pattern repeats for Alex (i = 1): result is scores[1 times 3 plus 0], scores[3], 27, then scores[1 times 3 plus 1], scores[4], 51, with count showing 2 then 3. Then for Roshana (i = 2): result is scores[2 times 3 plus 0], scores[6], 52, then scores[2 times 3 plus 1], scores[7], 55, with count showing 4 then 5, and a final row showing count on its own reaching 6 once both loops finish. Because the inner loop only ever runs for j = 0 and j = 1, never j = 2, each student's third score (72, 54 and 59) is never traced or output at all, even though the array scores clearly contains it.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise trace table questionsTrace a binary search on an eight-item, alphabetically sorted list, showing how the start, finish and mid pointers move on each pass until the target word is found.
A Python program implementing a binary search over an eight-item, alphabetically sorted list of animal names (cat, dog, hippo, llama, ox, rat, tiger, wolf, at indices 0 to 7). It repeatedly halves the search range using a mid index calculated as (start plus finish) integer-divided by 2, moving start up if the target is alphabetically after the midpoint animal, or finish down if it is before, until the target is found or the range is exhausted.
The search starts with start = 0 and finish = 7, giving mid = (0 + 7) // 2 = 3, which is llama. Since wolf is alphabetically after llama, start moves to mid + 1, which is 4, and finish stays at 7 throughout the whole trace since the target is never before the midpoint.
The next mid is (4 + 7) // 2 = 5, rat, and since wolf is after rat, start moves to 6. The next mid is (6 + 7) // 2 = 6, tiger, and since wolf is after tiger, start moves to 7. The final mid is (7 + 7) // 2 = 7, which is wolf itself, so validAnimal becomes True and the loop condition (validAnimal == False) is no longer met, ending the search on this pass.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise trace table questionsThe topic changes by sitting — the mark scheme never does. Learn this once, then open your question above for that sitting’s sources and a full worked answer.
What is the main purpose of a trace table?
Trace tables are the single most tested skill on this paper, worth at least 8 to 10 marks across two separate questions in every sitting we have. Practise tracing REPEAT UNTIL loops, nested FOR loops and binary searches until you can do it without skipping a row.
Practise trace table questionsThis appears at least once in every sitting we have full papers for, always split into design marks (for the right technique, even with imperfect syntax) and logic marks (for the actual outputs being correct).
Write a program that asks for the same piece of data twice, compares the two entries with a single IF/ELSE, and outputs a different message depending on whether they match.
email1 = input("Enter email address: ") email2 = input("Enter email address again: ") if email1 == email2: print("Match") print(email1) else: print("Do not match")
The Match branch outputs both the word Match and the actual email address, exactly as the question demands, while the Do not match branch outputs only the message, with the two outcomes kept in logically separate places (the IF branch and the ELSE branch) rather than both being printed unconditionally.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise selection programming questionsWrite a program with a three-way outcome (two different bonus formulas plus a zero-bonus case) driven by two inputs and a rule that combines two conditions with AND logic for one of the three outcomes.
items = int(input("Enter number of items sold: ")) years = int(input("Enter years employed: ")) if years <= 2 and items > 100: print(items * 2) elif years > 2: print(items * 10) else: print(0)
The three outcomes (double the items sold, ten times the items sold, or zero) sit in three logically separate branches (the IF, the ELIF and the ELSE), covering every combination the question describes: a low-tenure high-seller, anyone over 2 years employed regardless of sales, and everyone else who falls through to zero.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise selection programming questionsWrite a program that multiplies a per-person price by a group size, then conditionally subtracts a fixed discount if the group is large enough, using the exact boundary the question states (six or more, meaning >= 6).
group = int(input("Enter number of people: ")) total = group * 15 if group >= 6: total = total - 5 print(total)
The discount condition uses group >= 6, matching the question's exact wording of 'six or more people', not group > 6 which would wrongly exclude a group of exactly six, and the discount is applied by subtracting a flat 5 from the running total rather than recalculating the per-person price, before the final total is output once, in one place.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise selection programming questionsThe topic changes by sitting — the mark scheme never does. Learn this once, then open your question above for that sitting’s sources and a full worked answer.
Which programming construct is used to make a decision based on a condition?
Writing a short selection-based program from a real-world rule set comes up at least once every sitting, worth 5 to 7 marks. Practise translating exact wording like 'six or more' into the correct boundary condition every time.
Practise selection programming questionsThis appears once in both June 2022 (a card position between 1 and 100) and June 2023 (a two-character grid reference with a valid letter and a valid digit), always building on a starting line of code the question already gives you.
Wrap a given input line in a loop that keeps re-asking for a number until it falls strictly between 1 and 100 inclusive, correctly handling both boundary values.
One line of Python already given: position = int(input("Enter card position: ")), which the answer must extend into a full validation loop.
position = int(input("Enter card position: ")) while position < 1 or position > 100: position = int(input("Enter card position: "))
The condition checks both bounds explicitly, position < 1 for values too low and position > 100 for values too high, joined with OR so the loop keeps running if either invalid case is true, meaning 1 and 100 themselves are correctly treated as valid and the loop exits as soon as either is entered.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise input validation questionsExtend a given two-character-length check into a full validator that also confirms the first character is A, B or C and the second is 1, 2 or 3, re-prompting with a message until every rule passes.
Python code already given that repeatedly asks for a grid reference until it is exactly two characters long, converting it to uppercase each time. The answer must extend this to also check the individual characters are valid, using the variable check to control an outer loop.
check = False while check == False: square = "" while len(square) != 2: square = input("Enter grid reference (eg C2): ") square = square.upper() letter = square[0] number = square[1] if letter in "ABC" and number in "123": check = True else: print("Not valid, try again.")
The condition combines both character rules with AND: letter must be A, B or C, and number must be 1, 2 or 3, using Python's 'in' membership test against each allowed set, so check only becomes True once both individual characters are genuinely valid, and an appropriate re-prompt message is output in the else branch whenever either check fails.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise input validation questionsThe topic changes by sitting — the mark scheme never does. Learn this once, then open your question above for that sitting’s sources and a full worked answer.
A program asks the user to enter a score between 1 and 10. Which validation check should be used to ensure the number is within this range?
Extending a given line of code into a full validation loop comes up in every sitting we have, worth 4 to 6 marks. Practise getting both boundary values exactly right, since that is where marks are most often lost.
Practise input validation questionsThis is always the final or near-final question on the paper and always the highest single tariff of any one question, appearing once every sitting we have full papers for.
Write a subroutine that takes a 3 by 3 array as a parameter, counts every asterisk it contains using your own count logic rather than a built-in function, and outputs either the word Bingo (if all nine cells are marked) or the running count otherwise.
A 3 by 3 array called ticket, initially holding randomly generated key terms in every cell, which gets individual cells replaced with an asterisk as a player answers questions correctly. The subroutine checkWinner must take this array as a parameter, count how many cells now hold an asterisk (without using any built-in counting function), and output Bingo if the count is nine or the count itself otherwise.
def checkWinner(ticket): count = 0 for i in range(3): for j in range(3): if ticket[i][j] == "*": count = count + 1 if count == 9: print("Bingo") else: print(count)
The counter is initialised to 0 before the loop and incremented by exactly 1 every time a cell genuinely equals the asterisk character, using a Boolean equality test rather than any built-in count method, and the correct indices i and j are used to access every array element exactly once, before the final IF/ELSE outputs Bingo only on nine asterisks or the running count otherwise, in one final logically separate place.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise the biggest program-writing questionSimulate a dice game where two random dice are rolled and added to a running score each turn, the player chooses whether to roll again while under 21, and the final result (win, lose, or a random tiebreak roll if under 21) is worked out and reported.
A sample run of the finished program: on each turn it rolls two dice, adds them to a running score, outputs both rolls and the new score, and if the score is still under 21 asks the player whether to roll again. The example ends when a roll pushes the score to 22, over the limit of 21, and the program reports that the player lost.
import random score = 0 rollAgain = "yes" while rollAgain == "yes": dice1 = random.randrange(1, 7) dice2 = random.randrange(1, 7) score = score + dice1 + dice2 print("Roll 1: ", dice1) print("Roll 2: ", dice2) print("Current score: ", score) if score < 21: rollAgain = input("Would you like to roll again? ") else: rollAgain = "no"
if score > 21: print("You lost!") elif score == 21: print("You won!") else: tiebreak = random.randrange(15, 22) if tiebreak > score: print("You lost!") else: print("You won!")
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise the biggest program-writing questionThe topic changes by sitting — the mark scheme never does. Learn this once, then open your question above for that sitting’s sources and a full worked answer.
Which type of loop is best used when you know exactly how many times the loop should repeat?
The single biggest program-writing question on the paper is worth 8 to 11 marks every sitting we have. Practise breaking a long, multi-part specification into its design elements (loop, selection, data access) before writing a single line of code.
Practise the biggest program-writing questionThis appears once in both June 2022 (a wrong index used inside a loop) and June 2023 (a shadowed parameter and a backwards, out-of-range loop), always testing whether you can trace the actual bug, not just spot that something looks odd.
Trace a loop that generates and should print ten random numbers, and spot that it is actually printing the wrong array element every time, using the loop counter as the index instead of the random number itself, which will also crash once the counter exceeds the array's length.
A Python program intended to output 10 numbers, each randomly selected from an 8 element list called numbers, using random.randrange(0, 8) to generate a random index into that list inside a while loop controlled by a count variable.
The logic error is on line 7. The line reads print(numbers[count]), but count is the loop counter running from 1 up to 10, not the random index the program just generated on the previous line, so the program is printing whichever list element happens to sit at position count rather than a genuinely random one.
The corrected line should read print(numbers[number]), using the variable the program actually generated the random index into on the line above, rather than the counter. This also fixes a second, related problem: because count eventually reaches values above 7, the buggy version would eventually try to access an index that does not exist in the 8 element list and crash.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise debugging questionsFix two separate bugs in a subroutine meant to display currency names in reverse alphabetical order: a subroutine parameter that is never actually used inside the subroutine, and a FOR loop whose direction and bounds are both wrong.
A subroutine diffCurrencies declared with a parameter called currencies, but the subroutine body immediately reassigns currencies to a fresh 8 item list and then returns currencies[x], referencing a variable x that was never actually passed in or defined. The calling code then loops with FOR i, 8 TO 0 STEP 1, intending to display the list in reverse.
Line 1 should be rewritten as SUBROUTINE diffCurrencies(x), renaming the parameter to x so that it actually matches the variable used inside the subroutine on the RETURN line, since the original version declared a parameter called currencies that the RETURN statement never actually reads from.
Line 6 should be rewritten as FOR i FROM 7 TO 0 STEP -1, starting at index 7 (the last valid index in an 8 item list, not 8, which is out of range) and stepping backwards by 1 rather than forwards, since the loop needs to count down to produce reverse alphabetical order, starting with yen at the end of the list, ending at baht.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise debugging questionsThe topic changes by sitting — the mark scheme never does. Learn this once, then open your question above for that sitting’s sources and a full worked answer.
A program accepts scores between 0 and 100. Which value is an example of erroneous test data?
Finding and fixing a real bug comes up in every sitting we have. Practise tracing the buggy version by hand first, the exact same skill as a trace table question, before writing your corrected line.
Practise debugging questionsThis appears once in both June 2022 (completing a sound file size calculation subroutine) and June 2023 (completing a login authentication routine), always giving you more items in the bank than gaps, so guessing by elimination alone is not reliable.
Complete a subroutine that multiplies sample rate, sample resolution and duration to get a file size in bits, then divides by 8 to convert to bytes, choosing the correct parameter names, the correct arithmetic, and the correct RETURN and call syntax from the given word bank.
A partly complete subroutine getSize with two blanked parameter names plus a seconds parameter already given, a blanked line calculating a size value, a blanked conversion of that value from bits to bytes, and a blanked RETURN statement, followed by a blanked OUTPUT call passing the values 100, 16 and 60. Figure 11 gives a bank of possible items including sampRate, res, byte, bit, size / 8, size MOD 8, size * 8, RETURN, OUTPUT, SUBROUTINE, USERINPUT and getSize, with more items than gaps.
The two parameter gaps should be filled with sampRate and res, matching the two parameter names the rest of the subroutine's body already uses (sampRate * res * seconds), since the seconds parameter was already given and the multiplication line already references these two exact names.
The size in bits is converted to bytes using size / 8, dividing (not using MOD, which would give a remainder, or multiplying by 8, which would go the wrong direction), and the subroutine ends with RETURN size, passing the byte value back to the caller. The final call is OUTPUT getSize(100, 16, 60), matching the question's own stated inputs of a 100 times per second sample rate, 16 bit resolution and 60 seconds.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise pseudo-code completion questionsComplete a login algorithm's four blanked gaps: how a username is actually captured from the user, how it is passed into a subroutine that looks up its stored password, what an empty string result from that lookup means, and what message to show when it happens.
A login algorithm with four blanked gaps inside a REPEAT UNTIL structure: one gap where the username is actually captured from the user, one gap where the username is passed as an argument into a getPassword subroutine, one gap comparing the subroutine's returned storedPassword value against a specific value, and one gap giving the message shown when that comparison is true. Figure 6 gives a bank of possible items including USERINPUT, username, an empty string, the word True, the word SUBROUTINE, and messages like User not found and Wrong password, with more items than gaps.
The first gap, where the username is actually captured, should be filled with USERINPUT, since that is the item in the word bank whose role is capturing what the user types, and it directly matches the WHILE loop's own condition, which keeps re-asking until username is no longer an empty string.
The second gap, where getPassword is called, should be filled with username, passing the just-captured username into the subroutine as its argument, since the subroutine's whole job is looking up the stored password for that specific user. The third gap should be filled with an empty string, since the algorithm's own text explains the subroutine returns an empty string specifically when the username does not exist, and the fourth gap should be filled with the message User not found, which is the only item in the bank that correctly describes that exact situation, rather than Wrong password, which describes a different failure (a correct username but an incorrect password).
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise pseudo-code completion questionsThe topic changes by sitting — the mark scheme never does. Learn this once, then open your question above for that sitting’s sources and a full worked answer.
Which flowchart symbol is used to represent a decision?
A fill-the-gaps pseudo-code question comes up in every sitting we have, worth 4 to 6 marks. Practise reading the whole algorithm first, since most of the gaps only make sense once you understand what the finished algorithm is meant to do.
Practise pseudo-code completion questionsThis appears once in both June 2022 (state three advantages of using subroutines) and June 2023 (explain how the merge sort algorithm works), on a different named concept each time but always rewarding named, specific points rather than a vague general description.
Name three genuinely separate benefits of using subroutines (procedures and functions) rather than one long uninterrupted program, without repeating the same underlying idea in different words.
1. Subroutines can be developed and tested in isolation, independently of the rest of the program, which makes it easier to discover and fix errors, since a bug can be narrowed down to one specific, self-contained block of code rather than the whole program at once.
2. Subroutines make program code easier to read and understand, since related logic is grouped together under one meaningful name rather than scattered across a long, flat sequence of instructions. 3. Subroutines make it easier for a team of programmers to work together on a large project, since different people can write and test separate subroutines at the same time without constantly interfering with each other's code.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise explaining programming conceptsExplain the two distinct phases of merge sort: repeatedly splitting a list down into single-item sub-lists, then merging those sub-lists back together in the correct order until one fully sorted list remains.
A diagram showing a merge sort being carried out on a list, illustrating the list being split into progressively smaller sub-lists and then merged back together in sorted order.
Merge sort first repeatedly splits the list in half, at its midpoint, continuing to split each half again and again until every sub-list contains only a single item. A single-item list is always already considered sorted, since there is nothing left to compare it against.
The algorithm then merges these single-item sub-lists back together in pairs, comparing the items in each pair and placing the smaller (or alphabetically earlier) one first, repeating this merge-and-compare process on progressively larger sub-lists until a single, fully sorted list remains.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise explaining programming conceptsThe topic changes by sitting — the mark scheme never does. Learn this once, then open your question above for that sitting’s sources and a full worked answer.
Which design strategy does merge sort use?
A short, prose-only explanation question comes up in every sitting we have, worth 3 to 4 marks. Practise writing genuinely distinct points rather than the same idea reworded twice.
Practise explaining programming conceptsThis appears once in both June 2022 (comparing the efficiency of two different working programs that produce the same result) and June 2023 (explaining why a binary search cannot be used on a specific, unsorted list), always testing understanding of why an algorithm behaves the way it does, not whether you can trace it.
Decide which of two working programs, that both correctly add up the integers from 1 to a user-entered number, is more efficient: one that loops once per number, or one that calculates the same total directly using a formula, and explain why.
Two Python programs that both output the sum of every integer from 1 up to a number the user enters. Program A uses a FOR loop that runs once for every number in the range, adding each one to a running total. Program B calculates the same total directly in one step, using the arithmetic equivalent of Gauss's summation formula (multiplying the number by one more than itself, then halving the result), with no loop at all.
Program B is more efficient than Program A. Program A uses a FOR loop that executes once for every single number between 1 and the user's input, so if the user enters 1000, the loop body runs 1000 separate times to build up the total.
Program B instead calculates the same total in a fixed, constant number of steps, using a formula, regardless of how large the user's number is: entering 1000 takes exactly the same small number of calculations as entering 10. This means the number of calculations performed stays constant in Program B, but increases as the input number gets bigger in Program A, so Program B will take less time to execute, especially for large inputs.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise algorithm reasoning questionsRecognise that a binary search relies on the data already being in order, and that the specific list given in the question is not sorted, so the technique cannot be applied to it as it stands.
A line of Python code creating a list called fruits containing six fruit names in the order banana, apple, orange, pear, grape, pineapple, which is not in alphabetical order.
The list fruits is not ordered or sorted: its items (banana, apple, orange, pear, grape, pineapple) are not arranged alphabetically, so a binary search cannot be used on it as it stands.
Could you have written this? Every fact in this answer is drilled in our quizzes — the writing is the easy part once the evidence is automatic.
Practise algorithm reasoning questionsThe topic changes by sitting — the mark scheme never does. Learn this once, then open your question above for that sitting’s sources and a full worked answer.
Which of the following is a requirement before binary search can be used?
Reasoning about an algorithm's efficiency or suitability, without writing any code, comes up in every sitting we have. Practise linking your reasoning to the specific code or data given, not a generic rule with nothing to anchor it.
Practise algorithm reasoning questionsAcross the two sittings we have full papers for, Paper 1's overall structure and total marks (90) never changed, and the exact same handful of question archetypes appears in both papers, though the specific algorithm or programming task tested within each archetype is different every time.
Binary, hexadecimal or denary number conversion · Logic gates or Boolean logic truth tables · Computer systems topics such as the fetch-decode-execute cycle, CPU architecture or memory · Networking, protocols or network topologies · Cyber security, databases or SQL
These topics are genuinely part of the AQA 8525 specification, but they belong to Paper 2 (Computing concepts), not Paper 1, and did not appear as a standalone question on either Paper 1 sitting we analysed, so do not build your Paper 1 revision plan around them.
Yes, in both sittings we have full papers for. Every sitting totalled 90 marks in 2 hours, with no calculator allowed, and both papers were entirely focused on computational thinking, tracing algorithms, and writing, completing or debugging Python programs. Always check your own paper's front cover to confirm, since AQA can make real changes in any future series, and remember this is an untiered exam, so every candidate sits the same paper regardless of ability, choosing only which language option (C#, Python or VB.NET) matches what they were taught.
If you are entered for Option 1B, every question that requires a coded solution must be answered in Python specifically, as both papers state explicitly in their instructions. Pseudo-code is used by AQA in the question papers themselves to describe algorithms in a language-neutral way for tracing and completion questions, but when a question actually asks you to write a program, it must be genuine, working Python syntax. Entering candidates for Options 1A or 1C answer the same questions in C# or VB.NET instead, using the exact same mark scheme.
Every program-writing question in both mark schemes we reviewed splits marks into two types: design marks, for choosing the right technique (the right kind of loop, the right selection structure) even if your exact syntax is not perfect, and program logic marks, for the actual outputs being correct. Both mark schemes explicitly state that minor syntax errors should not be penalised as long as the logic flow of the program is unaffected, and that case (capital versus lowercase letters in your own code) is ignored entirely. However, most of these questions cap the marks available at a lower maximum, usually one or two below full marks, if there are genuine errors anywhere in the code, so a program that is mostly right but has one real, functional bug will not earn full marks even though small syntax slips alone would not be punished.
According to the real mark schemes for these two sittings, marks are very often lost on trace table questions by skipping a row, especially the very first row (the starting values before any loop has run) or the final row (the actual OUTPUT value), rather than any genuine misunderstanding of the algorithm itself. On the program-writing questions, the single most repeated cause of lost marks across both sittings was getting a boundary condition slightly wrong, such as using > instead of >= when a question says 'six or more' or 'between 1 and 100 inclusive', which silently excludes a value that should have been accepted.
Because neither real Paper 1 we analysed tested any of those topics. AQA GCSE Computer Science splits its two exams by skill, not by even coverage of every specification point: Paper 1 (Computational thinking and programming skills) is entirely about algorithms, tracing and writing programs, while data representation (binary, hexadecimal, images and sound), computer systems, networks, cyber security and databases are tested on Paper 2 (Computing concepts) instead. If you are looking for those topics, they belong on our Paper 2 page, not this one.
Every question type on this page has practice questions waiting in the app, built the way AQA actually structures Paper 1.
Start revising free