OCR A-Level · Analysis & Prediction

2024 OCR A-Level Computer Science - H446 Past Paper Analysis

An intensive and comprehensive assessment pair that probes deep into both theoretical system fundamentals (including unnormalised floating-point calculations, network protocols, and database structures) and complex algorithmic problem-solving (featuring OOP class design, A* traversal, stack/queue array implementations, and multi-faceted essays on search optimization and global variable scoping).

Updated: 14 Jun 2026

Analysis Sample paper

Difficulty 4.0/5

Total marks

280

Duration

300 mins

Most tested

Data Structures & Object-Oriented Program Design

Paper breakdown

H446/01: Computer Systems: 140 marks · 150 minsH446/02: Algorithms and Programming: 140 marks · 150 mins

Top chapters

Programming techniques · 45 marksData Structures · 45 marksAlgorithms · 31 marksStructure and function of the processor · 18 marks

Difficulty Verdict

The 2024 OCR A Level Computer Science examination series presents a highly rigorous challenge, continuing the modern trend of requiring deep application over rote learning. Paper 1 balances hardware theory with web indexing and database design, while Paper 2 tests candidates' core coding capabilities through an array-based game scenario in Section B and complex dry-runs in Section A. The difficulty is driven by mathematically demanding unnormalised-to-normalised floating-point conversions, logical circuit creations with several variables, and multi-stage algorithmic traces like the A* search.

Where the Marks Are

Marks are heavily concentrated in Data Structures and Programming Techniques (comprising over 30% of the total available credit). In Paper 1, the high-scoring opportunities rest in the three 9-to-12 mark essays covering layout cultural considerations, search engine indexing/PageRank, and flat file vs. relational databases. In Paper 2, Section B acts as a make-or-break zone where candidates must write and correct object-oriented code, including constructor methods, logic functions, and file structure corrections. Achieving top marks requires strong syntax precision in pseudocode and highly structured evaluative language in the extended essays.

Examiner Pitfalls

Examiner reports highlighted critical areas where even high-performing students consistently drop marks:

Pipelining Oversimplifications: Many candidates incorrectly stated that pipelining makes individual instructions run faster, rather than explaining that it overlaps FDE stages to increase overall instruction throughput.
Case Sensitivity in LMC: In Little Man Computer debugging, minor syntax issues such as using lowercase variable names (e.g., temp instead of the declared uppercase TEMP) resulted in immediate mark deductions.
De Morgan's Mechanical Errors: During Boolean simplification, students frequently forgot to change the operator (from \( \lor \) to \( \land \)) when negating terms.
A* Tracking Blunders: Many failed to update the 'Previous Node' column during the pathfinder trace, losing track of the correct cumulative cost calculations.

Strategy & Prediction

To excel in future sittings, students must treat coding as a core theoretical discipline rather than just a practical skill. Future papers are highly likely to shift focus back to overdue areas, particularly concurrency and computational methods, which were lightly assessed this series. Practising binary tree insertion logic, pointer alterations in queues/stacks, and the structural differences between graphs and trees will yield high study returns. Furthermore, mastering standard boilerplate patterns for OOP constructors and database normalisation remains the most efficient path to securing a high grade boundary.

Charts

Marks by chapter

See where the marks were concentrated so revision time goes to the highest-value topics.

Question type mix

Compare the mark share of each paper section and question type.

Short Answer65 marks · 32 questions
Structured / Programming / Coding156 marks · 34 questions
Extended Response / Essay59 marks · 6 questions

Mark accessibility

Estimate which marks were basic, mid-level, or high-difficulty.

75%within easy or medium reach

130

easy: 80 marksmedium: 130 markshard: 70 marks

Difficulty trend

Compare difficulty across recent years.

Command word frequency

Spot common command words so answers match the expected response style.

Skill weighting

Shows the skill mix this paper tested most heavily.

Study ROI

Bigger bubbles recur more often; higher bubbles carry more marks, helping you rank revision priorities.

Web Technologies

16 marks · Difficulty 3 · recurrence 90%

Data Structures

45 marks · Difficulty 3.5 · recurrence 95%

Systems Software

14 marks · Difficulty 2.5 · recurrence 85%

Thinking abstractly

13 marks · Difficulty 2.2 · recurrence 80%

Structure and function of the processor

18 marks · Difficulty 3 · recurrence 90%

Time vs marks

Compare marks with suggested time allocation to plan exam pacing.

marksmins

Next-year prediction

Topics worth watching next year, with the reason shown directly below each bar.

Thinking concurrently85%

Only featured briefly in 2023-jun (4 marks) and completely absent in 2024-jun. Expect a scenario-based question requiring concurrency analysis.

Moral and ethical Issues80%

Down from 9 marks in 2022 to 2 in 2023, and integrated heavily as interface considerations in 2024. A pure ethical/legal impact essay is highly due.

Boolean Algebra75%

Regularly tested (9 marks in 2023, 8 marks in 2024). It remains a staple component with predictable Karnaugh map or simplification mechanics.

Cumulative marks ladder

The line is your running mark total question by question; dashed lines are the estimated grade cut-offs. See which question the line crosses your target grade at, so you know how far you must answer cleanly and which questions decide a band.

Topic-year heatmap

Compare topic weight by year to spot recurring and returning areas.

Jun 2022

Jun 2023

Jun 2024

Programming techniques

Algorithms

Data Structures

Data Types

Structure and function of the processor

Databases

Software Development

Types of processor

Applications Generation

Moral and ethical Issues

Examiner insights

Official report

Common pitfalls

Confusing pipelining with parallel processing or multi-core execution; candidates often wrongly claimed pipelining makes individual instructions run faster rather than increasing overall throughput.
Incorrectly applying De Morgan's Law by forgetting to change the operator (OR to AND, or vice-versa) or failing to negate the individual terms properly.
In unnormalised to normalised floating-point conversions, candidates frequently changed the value of the exponent in the wrong direction or failed to pad the shifted mantissa correctly with trailing zeros to maintain an 8-bit length.
For A* algorithm tables, not updating the 'Previous node' column or failing to clearly specify the final calculated distance or exact path.
In OOP design, writing setter methods or return statements inside procedures (which shouldn't return values) or using pythonic self-syntax without matching consistent parameter naming rules.

Misconceptions

Believing that lossy compression can be used for text or program source code data, failing to recognise that losing any characters results in corrupt, unexecutable programs.
Believing that flat file databases are always useless; in reality, they are highly appropriate and simple to set up for small, static datasets like Rosa's initial 150 members.
Assuming global variables are always bad practice in software engineering, neglecting their temporary utility in small, rapid prototyping scenarios to minimize development overhead.

Where marks are lost

Failing to specify register and bus names clearly in description of the fetch stage (e.g., omitting that the Program Counter is sent to the MAR via the address bus).
Losing 1-2 marks on LMC tasks due to case-sensitivity errors in labels (such as using lowercase temp instead of UPPERCASE TEMP as defined in the DAT declarations).
Failing to write clear 'if/else' comparison structures with Boolean data types instead of string comparisons in stack-push validation conditions.
Failing to identify the four syntax errors in the displayRoad procedural loop, with common omissions being the incorrect upper bounds of the loop or incorrect getter function calls (using getValue instead of getName).

Estimated grade cut-off

Updated: 15 Jun 2026

Source: OCR

Level	Mark	Percentage
A*	355/420	85%
A	312/420	74%
B	262/420	62%
C	213/420	51%
D	164/420	39%
E	116/420	28%

Official grade boundaries published by OCR.

Know what the examiners want — now go get those marks

Thinka is an AI practice app used by 100,000+ DSE students to drill questions and get instant feedback on every answer. You already know the high-frequency topics and where marks are lost — now practice those specifically on Thinka and turn this analysis into actual marks.

Start Practising Free See pricing

Know what's tested? Drill those topics on Thinka — AI questions, instant marking.

Start Practising Free