OCR A Level Computer Science H446 — Specification Guide

OCR A Level Computer Science (H446) is a demanding specification that combines rigorous theory with practical programming. This guide breaks down every component, highlights the most challenging topics, and gives you a clear strategy for achieving your target grade.

Assessment Structure

H446 has three components:

Component	Name	Marks	Weighting	Format
H446/01	Computer Systems	140	40%	2 hr 30 min written
H446/02	Algorithms and Programming	140	40%	2 hr 30 min written
H446/03	Programming Project	70	20%	Coursework

Component 1: Computer Systems

1.1 The Characteristics of Contemporary Processors, Input, Output and Storage

CPU structure: ALU, CU, registers (PC, MAR, MDR, accumulator), cache (L1, L2, L3)
Instruction set architecture: CISC vs RISC — trade-offs between complexity and simplicity
Pipelining: how modern processors overlap fetch/decode/execute stages for multiple instructions
Parallel processing: multi-core, SIMD, MIMD architectures
I/O: ports, controllers, DMA (Direct Memory Access)
Secondary storage: magnetic, flash, optical — characteristics and applications

1.2 Software and Software Development

Categories: system software, application software
Operating system functions: memory management, process scheduling, file management, security, device management
Memory management: paging, segmentation, virtual memory
Process scheduling: round-robin, shortest job first, priority scheduling
Approaches to systems development: structured (waterfall) vs object-oriented; analysis, design, implementation, testing, evaluation

Examiner tip: OCR regularly tests pipelining and parallel processing in H446/01. Be able to explain hazards (data hazards, control hazards) and how they’re resolved.

1.3 Exchanging Data

Compression: lossy (JPEG, MP3) vs lossless (PNG, FLAC, run-length encoding, Huffman coding)
Encryption: symmetric (AES), asymmetric (RSA), key exchange, digital signatures, certificates
Databases: relational model, normalisation (1NF, 2NF, 3NF), SQL, ACID properties, transactions
Networks: topologies, protocols (TCP/IP stack), DNS, HTTP/HTTPS, packet switching
Web technologies: HTML, CSS, JavaScript (basic concepts), client-server model

1.4 Data Types, Data Structures and Algorithms

Primitive types: integer, real, Boolean, char, string
Composite types: arrays, records, classes
Dynamic data structures: linked lists, stacks, queues, trees, graphs
File organisation: serial, sequential, random (direct access)
Algorithms: searching (linear, binary), sorting (bubble, insertion, merge, quicksort), graph algorithms (Dijkstra’s, A*)

1.5 Legal, Moral, Cultural and Ethical Issues

Computer Misuse Act, Copyright, Data Protection Act/GDPR
Professional bodies and codes of conduct (BCS)
Environmental and social impacts of computing
AI ethics, surveillance, privacy

Component 2: Algorithms and Programming

H446/02 is the more applied paper. Expect questions that require you to write, trace, and analyse code.

2.1 Elements of Computational Thinking

Decomposition: breaking problems into sub-problems
Abstraction: removing irrelevant detail
Algorithmic thinking: identifying patterns, constructing step-by-step solutions
Modelling: representing real-world problems computationally

2.2 Problem Solving and Programming

Programming paradigms: procedural, object-oriented, functional
OOP in depth: encapsulation, inheritance, polymorphism, abstraction, interfaces
Functional programming: first-class functions, higher-order functions, partial application, currying, function composition
Event-driven programming: event handlers, triggers, callbacks

2.3 Algorithms

Core algorithms (know them by heart):

Linear and binary search
Bubble, insertion, merge, and quicksort
Dijkstra’s shortest path algorithm
A* search algorithm
Depth-first search (DFS) and breadth-first search (BFS)
Pre-order, in-order, post-order tree traversal

Complexity analysis:

Big O notation: O(1), O(log n), O(n), O(n log n), O(n²), O(2ⁿ)
Best, average, worst case analysis
Space complexity

Dijkstra’s — worked overview:

Assign infinity to all nodes; set source node to 0
Visit the unvisited node with the smallest current distance
Update distances to neighbours if a shorter path is found
Mark the current node as visited
Repeat until all nodes visited or destination reached

2.4 Further Programming

Recursion: base case, recursive step, stack frame analysis
OOP: class hierarchies, polymorphism in practice
File handling: sequential, random access, database querying
Exception handling: try/except, raising exceptions, custom exception classes
Regular expressions: pattern matching, validation

Component 3: Programming Project

The Programming Project (H446/03) is worth 20% and follows a structured format similar to AQA’s NEA, but with OCR’s own marking criteria.

Mark allocation

Section	Marks
Analysis	8
Design	12
Technical Solution	30
Testing	8
Evaluation	12

Key differences from AQA NEA

OCR’s Technical Solution section explicitly rewards software engineering practices: use of version control, testing framework, code documentation
Evaluation carries 12 marks (more than AQA’s 7) — take it seriously
OCR expects you to identify and justify your choice of programming language and paradigm

Project selection

The same principles apply as for any A Level CS project: real stakeholder, achievable scope, demonstrable complexity.

OCR specifically looks for evidence of:

Appropriate use of a programming paradigm (not just procedural code)
Abstract data structures (beyond simple lists)
File handling or database integration
A non-trivial algorithm that you have designed yourself

Technical solution quality

Higher mark bands require:

Decomposition into functions/methods with clear separation of concerns
Consistent coding style
Meaningful names throughout
Comments explaining non-obvious decisions
Evidence of iterative development (not a single monolithic program)

The Most Challenging Topics

Based on examiner feedback, these are the areas where H446 students consistently lose marks:

1. Functional programming

Many students have no prior exposure to functional programming. Key concepts:

Immutability: values don’t change; functions return new values
Higher-order functions: functions that take or return other functions
Map and filter: apply a function to every element, or filter elements matching a predicate
Currying: transforming a multi-argument function into a chain of single-argument functions

2. Floating point representation

Normalisation, underflow, and the trade-off between precision and range. This is poorly answered every year.

3. Dijkstra’s algorithm

Students know the concept but make errors in the table-based execution. Practice the full algorithm with multiple examples.

4. Karnaugh maps

Boolean simplification using K-maps is tested in H446/01. Not all students study this in class.

5. SQL (advanced)

Joins, nested queries, GROUP BY with HAVING, transactions. Go beyond basic SELECT/WHERE.

Revision Strategy

For Component 1:

Create detailed notes on each sub-section
Practice past paper question types (especially pipelining, floating point, SQL)
Use the OCR specification as a checklist — tick each point when you’re confident

For Component 2:

Write algorithms in pseudocode and code under timed conditions
Trace through Dijkstra’s and A* multiple times
Implement data structures from scratch (linked list, binary search tree, graph)

For the Project:

Start early — the best projects involve genuine iteration and refinement
Document as you go — don’t write the design after you’ve built it
Collect stakeholder feedback at multiple points, not just at the end

Resources

OCR publishes the H446 specification, sample assessment materials, and past papers on their website. The examiners’ reports are particularly valuable for understanding where marks are lost.

If you’re struggling with any aspect of H446 — the theory, the programming, or the project — book a 1-to-1 session. Sessions are tailored to your specific gaps and your specification.