CPX22Exam Technique for Papers 1 and 2

• Paper 1, Principles of Computer Science: Topics 1 to 5 (computational thinking, data, computers, networks, issues and impact). 1 hour 30 minutes, 75 marks, 50% of the GCSE.
• It is a written paper: you answer in the booklet with a black pen. No calculator is allowed.
• There are five questions, one per topic, each headed with the topic's name. The order of the topics changes every year, so don't expect “Data” to be first.
• Each topic question is worth roughly 8 to 20 marks and gets harder as it goes: short recall parts first, longer ones at the end.
• Every paper has one 6-mark Discuss, marked in levels, and one other 6-mark task that is points-marked: a flowchart to draw or complete, a trace table, a graph or a binary search to trace.
• Timing: 90 ÷ 75 = 1.2 minutes a mark. If you aim for about a mark a minute, you finish with 15 minutes to check.
• Paper 1 still has Python to read: code is printed in Pearson's style with line numbers down the side, for tracing, finding errors and naming the parts.

Same marks, different time and a different way of answering.

Ramped

Set out so that questions start easier and get harder as they go.

Pearson uses only the command words in Appendix 1 of the spec. The word, and the marks, tell you what to write.

• Paper 2 uses just two command words: Amend (change given code) and Write (create code), worth 5 to 15 marks.
• “Evaluate”, “Justify”, “Compare” and “Suggest” are not Pearson command words for this course. Practice questions that use them come from other boards.
• Underline three things in every question: the command word, the number asked for (“two”), and any “other than…” that rules an answer out.
• The marks are a guide to length: 1 mark is one point; “Explain one…” for 2 marks is one point and its linked reason.

Command word

The word in a question, such as Explain or Construct, that says what kind of answer is needed.

• Multiple choice (“Identify…”, options A–D): put a cross in one box. To change your mind, put a line through the box, then cross the new one.
• Read every option first. Pearson's wrong options are near-misses: 255 instead of 256 states, “IP” instead of “TCP/IP”, the layer next to the right one.
• Don't repeat the question. Mark schemes refuse anything the stem already says (“Do not award… given in the question”). If the stem says a device “performs a dedicated task”, writing that back scores 0.
• Use the precise term: “address bus”, not “the bus”; “2ⁿ” states, not 2ⁿ − 1; “True” or “False” for a relational test, not 1/0 or yes/no.
• Characteristics are features, not benefits. “Uses mnemonics” is a characteristic of assembly language; “easier to write” is a (vague) benefit.
• Vague words score nothing on their own: easier, quicker, better, cheaper, safer. Say what is easier and why.
• One answer per line. Don't hedge with two different answers to a “give one” question: a contradiction can cost the mark.

Stem

The part of a question that sets the scene and asks it, before any options or answer space.

Distractor

A wrong option in a multiple-choice question, often a common mistake.

• Explain one… (2 marks): make a point, then expand it with a linked reason. The mark schemes say the expansion must follow from, or be associated with, the first statement. Two unconnected points get 1 mark.
• Useful linking words: so, because, which means, therefore.
• Describe (2–4 marks): say what happens or what something is like, in developed, linked statements. No justification is needed, but each sentence should add a new step or detail.
• Use the context. If the question is about a garage's booking system, write about the garage, its bookings and its customers. Generic answers score less, and sometimes nothing.
• Keep to one idea when the question says “one”. Spend the second mark developing it, not starting another.

Linked expansion

A second statement that develops the first, such as its reason or consequence. Pearson gives the second mark for it.

• Paper 1 has no calculator, so most number questions say “Construct an expression… You do not have to do the calculation.” Write the expression; working it out is optional.
• Marks go to each component of the expression: the right numbers in the numerator, × 8 or ÷ 8 in the right place, the right powers of 1024 or 1000, then one for the whole thing.
• Equivalent forms are accepted: 1024², 1024 × 1024 and 2²⁰ are all fine, and so is a fraction. Show every factor rather than combining numbers in your head.
• Storage uses binary multiples: KiB, MiB, GiB and TiB go up in 1024s. Pearson says denary multiples are not acceptable for storage.
• Network speeds use 1000s: 1 Mbps = 1000 × 1000 bits per second. A transmission-time expression mixes the two: size in bits (with 1024s) ÷ speed (with 1000s).
• Common slips: forgetting × 8 to turn bytes into bits; minutes not turned into seconds; extra data (such as metadata) added inside the numerator instead of to the whole size.
• Conversions (denary to binary, binary to hex) need the exact format: 8 bits means 8 bits, leading zeros included. A 7-bit answer can score 0.
• “Calculate” (rarer) needs working and the unit.

Binary multiple

A unit that goes up in 1024s (KiB, MiB, GiB, TiB). Used for storage.

Denary multiple

A unit that goes up in 1000s (kilobit, megabit). Used for network speeds.

• Algorithms in Paper 1 are shown as Python with line numbers, as flowcharts, or as written descriptions. You can answer an algorithm question in any of these, unless it asks for one (“Draw a flowchart”, “Write the corrected line of code”).
• There is no Pearson pseudocode language: “pseudocode” just means an informal written description. Don't use the old SET … TO style from older Edexcel books.
• Flowcharts use Pearson's six symbols (below). Examiners look for: Start and Stop terminators, the right symbol for each step, exactly two labelled exits from each decision, an arrowhead on every flow line, and no box left hanging. A valid, clear symbol that isn't on the list still gets credit.
• Trace tables: start with the values before the loop; write a new value only when it changes; write in the Output column only when a print runs. “You may not need to use all the rows” is normal.
• Watch the loop limits: range (1, 5) gives 1, 2, 3, 4. The commonest trace error in reports is one pass too many.
• Completing a table (a bus for each job, a protocol for each description): one answer per cell, using the exact term.
• Code-reading questions: give exactly what is asked (a line number, or the lines of a whole block). “Write the corrected line” means the whole line of Python, corrected.

The only six symbols Pearson uses in its flowcharts.

1  total = 0
2  for n in range (3, 10, 3):
3      total = total + n
4  print (total)

Trace table

A table that records the value of each variable, and any output, as an algorithm is followed step by step.

A real Paper 1 has one Discuss question, not one per topic. So far it has always been a part of Question 4, but don't rely on that. It is the only levels-marked question on the paper.

• The stem gives a context, then “Your answer should consider:” and two or three bullets. Level 3 needs every bullet: mark schemes say so (“Level 3 responses must cover both…”).
• Plan for a minute: one paragraph per bullet, two or three developed points in each.
• Each point: what (the computing fact), so what (its effect), here (why it matters in this context).
• Definitions alone stay in Level 1. A long list of unlinked points stays in Level 1 too: depth beats length.
• Use the technical terms from the topic, correctly. Waffle is ignored, but a wrong fact can count against you.
• A short closing sentence that pulls the bullets together helps the structure. It doesn't need to be a verdict.
• Allow about 8 minutes.

Linking points to the context is what moves an answer up the levels.

Levels-based mark scheme

A mark scheme that places the whole answer in a level by its quality, then gives a mark within that level.

Indicative content

The points a mark scheme expects a good answer might include. Other valid points also get credit.

• Paper 2, Application of Computational Thinking: Topic 6. 2 hours, 75 marks, 50%. Six questions, all answered by writing or changing Python 3 code on a computer. There are no written answers.
• You use an IDE you know, which must show line numbers: questions point you to particular lines. Turn line numbers on before the exam if your IDE hides them.
• Your user area has a STUDENT CODING folder with the starting files Q01.py to Q06.py, any data files (.txt) and the PLS, and an empty COMPLETED CODING folder.
• Save each answer in COMPLETED CODING with the exact name the question gives, such as Q03FINISHED.py. Don't overwrite the original files. The centre zips your COMPLETED CODING folder and sends it to Pearson, where examiners run your code.
• On the desk: the printed question paper with the PLS (Programming Language Subset) in it; the PLS is on screen too. You may use a calculator, including the one on the computer, and the IDE's offline help.
• Not allowed: the internet, AI tools or anything that writes code for you, textbooks or notes, and USB sticks. Ordinary auto-complete in the IDE is allowed.
• Save often. Pearson's own advice on the cover is “Save your work regularly”.

Open from STUDENT CODING, save to COMPLETED CODING: only that folder is sent.

PLS (Programming Language Subset)

Pearson's list of the Python you need for Paper 2. You get it in print and on screen in the exam.

IDE

Integrated development environment: the program you write, run and debug your code in.

Each question is one of Pearson's task types. The instructions are on the paper and in the file, in comments that start # =====>.

• Points marks: roughly one mark per required change or feature, each in the right place. The mark scheme lists them line by line. Fix-the-errors code is checked for each fix, so partial work still scores.
• Levels marks: the longer questions add one, two or three strands of 3 marks each: Solution design, Good programming practices and Functionality. The last question (15 marks) always has all three: 6 points + 9 levels marks.
• Functionality is judged by running your code with the test data in the mark scheme, so a file that won't run loses most of it.
• Instructions often end “Do not change the functionality of the given lines” and “Do not add any additional functionality”. Extra features, or extra validation nobody asked for, earn nothing.
• Use the constants and variables provided. Typing 30 where the file has MAX_DAYS loses marks.

Points for each required change; levels for the program as a whole.

Original line number

A line's number in the starting file, before you edit it. Paper 2 questions use these.

Test data

The inputs and expected outputs in the question. Examiners run your code with test data.

• Run your code after every change, and always with the test data printed in the question. Most logic errors that cost marks would have shown up on one run.
• Read Python's error message: the type (SyntaxError, NameError, TypeError, ValueError, IndexError, AttributeError) and the line number tell you where to look.
• Fix syntax errors first: a file that won't run can't show its Functionality.
• Check the boundaries: if the rule is “7 nights or more”, test 6 and 7 as well as an obvious value.
• Timing: 120 ÷ 75 = 1.6 minutes a mark. Each question shows a “Suggested time”, and they add up to the full 2 hours, so keep to them.
• Stuck? Save what you have and move on. A part-finished program still earns the points for what is there and often a level mark. Come back if you have time.
• On the open task, spend the first few minutes planning: inputs, outputs, data structures, subprograms. Then build and test it one part at a time, so you always have something that runs.

Pearson's suggested times on a typical Paper 2.

Boundary test

Testing with values at the edge of a rule, such as 6 and 7 for “7 or more”.