UniGeniusA-level Computer Science · OCR H446

The whole course, area by area

All 77 units of OCR H446 in teaching order, across Paper 1, Paper 2 and the project. Open a unit to see what it asks you to do.

Computational thinking Paper 2 · Algorithms and programming · 1 of 4 taught

  • A tour of A-level Computer Science
    • Integer arithmetic, negative values, powers of two and quotient/remainder
    • Algebraic substitution, functions and explicit input/output contracts
    • Sets, Boolean propositions and interpreting a small truth table
    • Read tables, indexed positions and simple graphs; distinguish data from claims
    • Explain a causal mechanism and compare the same feature on both sides
    Lesson
  • 2.1.1(a), 2.1.1(b), 2.1.1(c), 2.1.1(d)
    Abstraction and model limits
    • Explain abstraction as selection of relevant detail
    • Justify why abstraction helps solve this problem
    • Identify what an abstract model omits and how that limits its use
    • Devise and validate an abstract model for a new situation
    Coming
  • 2.1.2(a), 2.1.2(b), 2.1.2(d)
    Inputs, outputs, preconditions and reusable components
    • Specify inputs and outputs precisely
    • State preconditions for a valid solution
    • Specify a reusable component contract
    Coming
  • 2.1.3(a), 2.1.3(b), 2.1.3(c), 2.1.3(d), 2.2.2(a), 2.2.2(b), 2.2.2(c), 2.2.2(e)
    Decomposition and procedural planning
    • Decompose a problem into meaningful parts
    • Assign a solution responsibility to each part
    • Order the required steps and identify dependencies
    • Define subprocedures and their interfaces
    • Decide whether a problem has computable inputs, rules and outputs
    • Recognise the actual problem and distinguish symptoms from requirements
    • Decompose and recombine a computational solution
    • Use abstraction without discarding necessary constraints
    Coming

Programming Paper 2 · Algorithms and programming · 5 of 8 taught

  • 2.1.4(a), 2.1.4(b), 2.1.4(c)
    Decisions and Boolean conditions
    • Locate the decisions required in a solution
    • Derive Boolean conditions including boundary cases
    • Trace how decisions alter program flow
    LessonPractice
  • 2.2.1(a), 1.2.3(c), 1.2.4(b)
    Sequence, selection and iteration
    • Trace and write sequence, selection and count/condition-controlled iteration
    • Write and follow a solution algorithm before implementation
    • Design a procedural solution with a clear control flow
    LessonPractice
  • 1.4.1(a), 2.2.1(a), 1.4.2(a)
    Types, strings, files and array indexing
    • Choose integer, real, character, string or Boolean and explain the choice
    • Process strings, arrays and files using appendix 5d conventions
    • Trace 1D, 2D and 3D arrays, records, lists and tuples
    LessonPractice
  • 2.2.1(c), 2.2.1(d)
    Functions, procedures, scope and parameters
    • Trace local and global scope and variable lifetime
    • Use functions, procedures and modular contracts
    • Trace parameter passing by value and by reference
    LessonPractice
  • 2.2.1(e)
    Debugging in an IDE
    • Use IDE breakpoints, stepping and watches to diagnose syntax, runtime and logic errors
    Coming
  • 2.2.1(b)
    Recursion and iteration
    • Trace recursive calls, base case and return values
    • Compare a recursive solution with an iterative alternative
    LessonPractice
  • 1.2.4(e), 2.2.1(f)
    Classes and objects
    • Distinguish classes, objects, methods and attributes
    • Implement classes, constructors, attributes and methods using object-oriented techniques
    Coming
  • 1.2.4(e), 2.2.1(f)
    Encapsulation, inheritance and polymorphism
    • Use encapsulation, inheritance and polymorphism in an appropriate model
    • Implement inheritance and encapsulation using object-oriented techniques
    Coming

Data representation Paper 1 · Computer systems · 4 of 5 taught

  • 1.4.1(b), 1.4.1(e), 1.4.1(f)
    Unsigned binary, hexadecimal and denary
    • Represent an unsigned integer at an explicit binary width
    • Represent an unsigned integer in hexadecimal
    • Convert binary, hexadecimal and denary without a calculator
    LessonPractice
  • 1.4.1(c), 1.4.1(d)
    Signed binary and integer arithmetic
    • Encode and decode sign-and-magnitude and two's-complement integers
    • Add and subtract binary integers and identify overflow
    LessonPractice
  • 1.4.1(g)
    Floating-point representation and normalisation
    • Decode a binary mantissa/exponent format with explicit sign convention
    • Normalise positive and negative binary floating-point values
    LessonPractice
  • 1.4.1(h)
    Floating-point arithmetic and precision
    • Align exponents and add or subtract positive and negative floating-point values
    • Explain range, precision, rounding and overflow for a stated format
    Coming
  • 1.4.1(i), 1.4.1(j)
    Shifts, masks and character sets
    • Apply logical or arithmetic shifts as specified and interpret bit loss
    • Apply AND, OR and XOR masks to set, clear, toggle or extract bits
    • Explain ASCII and Unicode character encodings and character/code distinction
    LessonPractice

Boolean algebra and logic Paper 1 · Computer systems · 3 of 3 taught

  • 1.4.3(a), 1.4.3(d)
    Boolean expressions, truth tables and gates
    • Translate a decision requirement into a Boolean expression
    • Construct and check truth tables against logic-gate diagrams
    LessonPractice
  • 1.4.3(b), 1.4.3(c)
    Boolean laws and Karnaugh maps
    • Simplify with a Karnaugh map using valid adjacency and wraparound
    • Derive equivalent expressions using De Morgan, distribution, association, commutation and double negation
    LessonPractice
  • 1.4.3(e)
    Adders and D-type flip-flops
    • Trace a D-type flip-flop and distinguish sequential from combinational logic
    • Derive half-adder and full-adder sum and carry outputs
    LessonPractice

Processors, software and development Paper 1 · Computer systems

  • 1.1.1(a), 1.1.1(b)
    CPU components, buses and fetch/decode/execute
    • Explain ALU and control-unit roles and distinguish PC, ACC, MAR, MDR and CIR
    • Trace data, address and control buses alongside an assembly instruction
    • Trace register changes through fetch, decode and execute
    Coming
  • 1.1.1(c), 1.1.1(d), 1.1.1(e)
    Architecture, performance and processor pipelines
    • Explain clock, cores and cache effects with workload limits
    • Model a pipeline and explain throughput, latency and hazards
    • Compare Von Neumann, Harvard and contemporary combined architectures
    Coming
  • 1.1.2(a), 1.1.2(b), 1.1.2(c)
    RISC, CISC, GPUs, multicore and parallel systems
    • Choose RISC or CISC using instruction and implementation trade-offs
    • Match a GPU to graphics and non-graphics parallel workloads
    • Distinguish multicore hardware from parallel execution and justify a use
    Coming
  • 1.2.4(a), 1.2.4(c), 1.2.4(d)
    LMC tracing, programming and addressing
    • Explain why different programming paradigms suit different tasks
    • Trace an LMC program using memory, accumulator, branches and I/O
    • Write and repair an LMC program with labelled data locations
    • Resolve immediate, direct, indirect and indexed operands
    Coming
  • 1.1.3(a), 1.1.3(b), 1.1.3(c), 1.1.3(d)
    Input/output, storage, RAM, ROM and virtual storage
    • Choose input and output devices and explain their use in the stated problem
    • Compare magnetic, flash and optical storage against capacity, speed, cost and durability
    • Distinguish RAM and ROM by role and persistence
    • Explain virtual storage and distinguish it from virtual memory
    Coming
  • 1.2.1(a), 1.2.1(b), 1.2.1(f), 1.2.1(g)
    OS roles, memory, BIOS and drivers
    • Explain OS responsibilities rather than naming a generic benefit
    • Trace paging, segmentation and virtual-memory access
    • Explain the BIOS role during startup
    • Explain why an OS needs a device driver
    Coming
  • 1.2.1(c), 1.2.1(e)
    Interrupts and OS categories
    • Trace interrupt detection, saved state, ISR execution and resumption
    • Select distributed, embedded, multitasking, multi-user or real-time OS behaviour
    Coming
  • 1.2.1(d)
    Scheduling algorithms
    • Trace round robin and first come first served with waiting-time consequences
    • Trace shortest job first and shortest remaining time including pre-emption
    • Explain priority movement and time slices in a multilevel feedback queue
    Coming
  • 1.2.1(h), 2.1.2(c)
    Virtual machines and caching
    • Explain virtual hardware and intermediate-code virtual machines
    • Evaluate caching using hit rate, stale data, memory and computation trade-offs
    Coming
  • 1.2.2(a), 1.2.2(b), 1.2.2(c)
    Applications, utilities and source/licence choices
    • Justify an application category against a user requirement
    • Match a utility to its precise maintenance or protection function
    • Evaluate source-access, licence, support and modification trade-offs
    Coming
  • 1.2.2(d), 1.2.2(e), 1.2.2(f)
    Translators, compiler stages, linking and loading
    • Compare compilation, interpretation and assembly
    • Trace lexical analysis, syntax analysis, code generation and optimisation
    • Explain linking, loading and the use of libraries
    Coming
  • 1.2.3(a), 1.2.3(b)
    Development methodologies
    • Model waterfall, agile, extreme programming, spiral and rapid application development
    • Choose a methodology using uncertainty, feedback, risk and delivery constraints
    Coming

Exchanging data Paper 1 · Computer systems

  • 1.3.1(a), 1.3.1(b)
    Compression: lossy, run length and dictionary coding
    • Choose lossy or lossless compression for a stated fidelity requirement
    • Encode and decode run-length data and calculate a size comparison
    • Trace dictionary coding and distinguish dictionary entries from literals
    Coming
  • 1.3.1(c), 1.3.1(d)
    Encryption and hashing
    • Explain symmetric and asymmetric key roles in a communication scenario
    • Distinguish hashing uses for integrity, passwords and indexing from encryption
    Coming
  • 1.3.2(a)
    Relational modelling, keys, relationships and indexing
    • Distinguish flat files, relational tables, records and fields
    • Identify primary, foreign and secondary keys and explain an index
    • Draw and interpret entity relationships and cardinalities
    Coming
  • 1.3.2(b), 1.3.2(c)
    Data capture and normalisation to 3NF
    • Choose methods for capturing, selecting, managing and exchanging data
    • Normalise to 1NF, 2NF and 3NF using keys and dependencies
    Coming
  • 1.3.2(d)
    SQL filters, wildcards and joins
    • Interpret and modify SELECT, filters, wildcards and inner joins
    Coming
  • 1.3.2(d), 1.3.2(e)
    Nested SQL, data changes and referential integrity
    • Interpret and modify nested SELECT, INSERT, DELETE and DROP in a disposable database
    • Explain referential integrity and valid update/delete consequences
    Coming
  • 1.3.2(f)
    Transactions, ACID, locking and redundancy
    • Apply ACID, record locking and redundancy to a transaction scenario
    Coming
  • 1.3.3(a), 1.3.3(d), 1.3.3(e)
    Network standards, hardware and client/server models
    • Explain why compatible protocols and standards are needed
    • Choose and explain network hardware roles
    • Compare client-server and peer-to-peer against a scenario
    Coming
  • 1.3.3(b)
    TCP/IP, DNS, layering and switching
    • Trace a message through TCP/IP layers and explain encapsulation
    • Explain DNS resolution, internet structure, LAN and WAN
    • Compare packet and circuit switching for a stated workload
    Coming
  • 1.3.3(c)
    Network threats and protections
    • Explain specific network threats and how firewall, proxy and encryption mitigate them
    Coming
  • 1.3.4(a)
    HTML, CSS and JavaScript
    • Read and modify the specified HTML elements and attributes
    • Apply inline or external CSS with element, class and ID selectors
    • Trace and write basic JavaScript that processes given input and changes output
    Coming
  • 1.3.4(b), 1.3.4(c), 1.3.4(d)
    Search indexing, PageRank and client/server processing
    • Explain crawling and search-engine indexing
    • Explain PageRank using inbound links and their relative importance
    • Choose client-side or server-side processing using trust, speed and resource constraints
    Coming

Data structures and algorithms Papers 1 and 2 · 3 of 11 taught

  • 1.4.2(b), 1.4.2(c)
    Stacks, queues and linked lists
    • Represent linked lists with links and a start pointer
    • Represent stacks and queues using indices or links
    • Create, traverse, insert into and delete from a linked list
    • Implement stack push/pop and queue enqueue/dequeue with full and empty cases
    Coming
  • 1.4.2(b), 1.4.2(c)
    Graphs, trees, BSTs and hash tables
    • Represent directed and undirected graphs and explain graph terminology
    • Distinguish trees, binary search trees and hash tables
    • Insert, find, traverse and remove values in a tree or binary search tree
    • Insert, find and remove hash entries while resolving collisions
    • Operate on graph representations and preserve edge direction
    Coming
  • 2.3.1(a), 2.3.1(b), 2.3.1(c), 2.3.1(d)
    Algorithm design, time/space and Big O
    • Design and justify an algorithm for an unfamiliar specification
    • Choose an algorithm by input conditions, time and memory
    • Classify constant, logarithmic, linear, polynomial and exponential growth
    • Measure operations and distinguish empirical timing from asymptotic complexity
    • Compare complexities while stating input size and best/average/worst assumptions
    Coming
  • 2.3.1(e)
    Data-structure algorithms and tree traversals
    • Design and trace stack, queue and linked-list algorithms
    • Trace depth-first post-order and breadth-first tree traversal
    Coming
  • 2.3.1(f)
    Linear and binary search
    • Trace and implement binary search with sorted-input precondition
    • Trace and implement linear search with found/not-found outcomes
    LessonPractice
  • 2.3.1(f)
    Bubble and insertion sort
    • Trace and implement bubble sort with a justified stopping condition
    • Trace and implement insertion sort including shift operations
    LessonPractice
  • 2.3.1(f), 2.2.2(d)
    Merge sort, quicksort and divide and conquer
    • Trace and implement merge sort with split and merge stages
    • Trace and implement quicksort with a stated partition/pivot convention
    • Apply divide and conquer and explain recombination costs
    LessonPractice
  • 2.3.1(f)
    Dijkstra and A*
    • Trace Dijkstra using distance, predecessor and visited state
    • Trace A* using g, h and f with an explicit tie-break rule
    Coming
  • 2.1.5(a), 2.1.5(b), 2.2.2(f)
    Concurrency and pipelining as computational methods
    • Identify independent and dependent parts of a problem
    • Evaluate time savings, coordination overhead and shared-state risks
    • Apply pipelining to a process and distinguish latency from throughput
    Coming
  • 2.2.2(f)
    Backtracking, heuristics and computational method choice
    • Trace backtracking choices, failure and reversal
    • Use a heuristic and explain its quality/optimality limits
    Coming
  • 2.2.2(f)
    Data mining, performance modelling and visualisation
    • Choose data mining for patterns rather than claiming causation
    • Build and interpret a performance model with assumptions
    • Choose a visualisation that exposes a relevant pattern or state
    Coming

Law, ethics and society Paper 1 · Computer systems

  • 1.5.1(a), 1.5.1(b), 1.5.1(c), 1.5.1(d)
    Computing legislation and exam/current-law distinction
    • Apply the syllabus-named Data Protection Act 1998 principles to an exam scenario and label its historical status
    • Apply Computer Misuse Act 1990 categories to a computing scenario
    • Apply Copyright, Designs and Patents Act 1988 to software and digital content
    • Explain the syllabus scope of Regulation of Investigatory Powers Act 2000
    Coming
  • 1.5.2: workforce, 1.5.2: decisions, 1.5.2: ai
    Ethics: workforce, automated decisions and AI
    • Evaluate workforce displacement, new roles and unequal impacts
    • Evaluate automated decision making using fairness, responsibility and contestability
    • Evaluate AI opportunities and risks in a concrete deployment
    Coming
  • 1.5.2: environment, 1.5.2: censorship, 1.5.2: monitoring, 1.5.2: personal-data
    Ethics: environment, censorship, monitoring and data
    • Compare energy, materials, e-waste and lifecycle impacts
    • Evaluate censorship and internet access from several stakeholder positions
    • Evaluate monitoring of behaviour against privacy and safety
    • Evaluate personal-information analysis, consent and potential harm
    Coming
  • 1.5.2: communications, 1.5.2: access
    Ethics: communications, culture and accessibility
    • Distinguish piracy and offensive communications from adjacent legal and ethical issues
    • Evaluate layout, colour conventions and character sets for cultural and accessible use
    Coming

Programming project Component 03/04 · 20%

  • 3.1.1(a), 3.1.1(b)
    NEA: Problem identification
    • Justify computationally solvable features of the learner's own problem
    • Explain why a computational solution suits that problem
    Coming
  • 3.1.2(a)
    NEA: Stakeholders
    • Identify real stakeholder groups or personas and link needs to the proposed solution
    Coming
  • 3.1.3(a), 3.1.3(b), 3.1.3(c)
    NEA: Research the problem
    • Compare relevant existing approaches and justify independent design decisions
    • Explain which essential solution features follow from the research
    • Explain limitations and their practical consequences
    Coming
  • 3.1.4(a), 3.1.4(b)
    NEA: Specify the proposed solution
    • Justify functional and appropriate hardware/software requirements
    • Write measurable success criteria traceable to stakeholder needs
    Coming
  • 3.2.1(a)
    NEA: Decompose the problem
    • Justify a decomposition into implementable responsibilities
    Coming
  • 3.2.2(a), 3.2.2(b), 3.2.2(c), 3.2.2(d)
    NEA: Describe the solution
    • Explain and justify complete solution structure
    • Specify accurate algorithms and show how they form a complete solution
    • Justify usable interaction and interface features
    • Justify variables, structures, classes and validation
    Coming
  • 3.2.3(a)
    NEA: Describe the approach to testing
    • Justify iterative and final test data including boundaries and invalid inputs
    Coming
  • 3.3.1(a), 3.3.1(b)
    NEA: Iterative development process
    • Record each development stage with learner-authored evidence, review and justified decisions
    • Retain prototype evidence and connect each change to a need or finding
    Coming
  • 3.3.2(a), 3.3.2(b)
    NEA: Testing to inform development
    • Record predicted and observed test outcomes at each meaningful stage
    • Document actual failed tests, repairs and retests with reasons
    Coming
  • 3.4.1(a), 3.4.1(b)
    NEA: Testing to inform evaluation
    • Evidence final functional and robustness tests
    • Evidence genuine usability tests and user feedback
    Coming
  • 3.4.2(a)
    NEA: Success of the solution
    • Evaluate every success criterion against identified test evidence
    Coming
  • 3.4.3(a)
    NEA: Describe the final product
    • Evaluate the effectiveness of evidenced usability features
    Coming
  • 3.4.4(a), 3.4.4(b)
    NEA: Maintenance and development
    • Explain maintainability using concrete code and documentation evidence
    • Propose justified further work for limitations or unmet criteria
    Coming

Exam skills Papers 1 and 2

  • 3h
    Point answers, comparisons and trace repairs
    • Meet the command word and every explicit prompt requirement
    • Explain an accurate mechanism with linked cause and consequence
    • Use the particular scenario constraints to support a claim
    • Trace, test and justify a program independently of its surface syntax
    Coming
  • 3h
    9-mark discussion workshop
    • Meet the command word and every explicit prompt requirement
    • Explain an accurate mechanism with linked cause and consequence
    • Use the particular scenario constraints to support a claim
    • Compare matching dimensions and develop trade-offs
    • Justify a conclusion from the analysis when the task calls for it
    • Communicate a coherent, relevant line of reasoning
    Coming
  • 3h
    12-mark evaluation workshop
    • Meet the command word and every explicit prompt requirement
    • Explain an accurate mechanism with linked cause and consequence
    • Use the particular scenario constraints to support a claim
    • Compare matching dimensions and develop trade-offs
    • Justify a conclusion from the analysis when the task calls for it
    • Communicate a coherent, relevant line of reasoning
    Coming
  • 1.1.1(b), 1.1.1(c), 1.3.2(d), 1.4.1(h), 1.5.2: ai
    Paper 1 timed integration
    • Trace register changes through fetch, decode and execute
    • Explain clock, cores and cache effects with workload limits
    • Interpret and modify SELECT, filters, wildcards and inner joins
    • Align exponents and add or subtract positive and negative floating-point values
    • Explain range, precision, rounding and overflow for a stated format
    • Evaluate AI opportunities and risks in a concrete deployment
    Coming
  • 2.2.1(a), 2.2.1(d), 2.2.1(f), 2.3.1(a), 2.3.1(b), 2.3.1(f)
    Paper 2 scenario integration
    • Trace and write sequence, selection and count/condition-controlled iteration
    • Process strings, arrays and files using appendix 5d conventions
    • Use functions, procedures and modular contracts
    • Trace parameter passing by value and by reference
    • Implement classes, constructors, attributes and methods using object-oriented techniques
    • Design and justify an algorithm for an unfamiliar specification
    • Choose an algorithm by input conditions, time and memory
    • Trace and implement binary search with sorted-input precondition
    Coming

Independent practice for OCR A-level Computer Science (H446), not endorsed by OCR.

Privacy · Terms