OCR A-Level Computer Science

Last Accessed

Recently visited lessons will appear here for quick access.Start exploring your first lesson today!

Computer systems (01)

Processors, input, output and storage

1.1.1 - CPU components, registers and busesA processor carries out instructions by moving values between small storage locations and the circuitry that acts on them. You will follow those movements to distinguish a memory address, an instruction and a result. This makes assembly-language instructions more meaningful than a list of abbrevi...
1.1.1 - The fetch-decode-execute cycleStored instructions cannot act until the processor retrieves and interprets them. You will trace the fetch-decode-execute cycle using addresses, register contents and bus transfers. Following a complete small program also shows why a branch can change which instruction is fetched next.
1.1.1 - CPU performance and pipeliningA higher advertised clock speed does not guarantee that every program finishes sooner. You will explain how clock frequency, cores and cache affect actual work, then follow overlapping instruction stages in a pipeline. The useful question is which part of a particular workload each change can imp...
1.1.1 - Von Neumann and Harvard architecturesA processor needs both instructions and the data those instructions use. The arrangement of memories and transfer paths affects whether those demands compete. You will compare Von Neumann and Harvard designs, then explain how a contemporary processor can combine ideas from both.
1.1.2 - RISC and CISC processorsProcessors can offer different kinds of instructions for doing the same job. You will compare RISC and CISC approaches by following the work their instructions express and the hardware that implements it. Their useful trade-offs depend on the program, implementation and constraints of the device.
1.1.2 - GPUs, multicore and parallel systemsSome workloads contain many operations that can happen together, while others depend on a strict sequence. You will distinguish CPU cores, GPUs and wider parallel systems, then judge when sharing work can help. Graphics is an important example, but the same reasoning explains non-graphics applica...
1.1.3 - Choosing input, output and storageA device is suitable when its characteristics meet the needs of the task. You will connect ways of entering and presenting data to practical situations, then compare magnetic, optical and flash storage. The useful judgement is a reasoned choice about access, capacity, durability and cost, rather...
1.1.3 - RAM, ROM and virtual storageA program needs working memory while it runs, instructions available when the machine starts, and somewhere to keep saved files. You will distinguish the roles of RAM and ROM, then follow a file stored remotely through a familiar local-looking drive. That also explains why virtual storage does no...

Software and software development

1.2.1 - Operating systems, BIOS and driversOpening, editing and printing a document involves more than the application alone. You will follow the operating system's resource and file services, the firmware that starts the machine, and the driver that communicates with a device. These layers let applications use hardware through organised,...
1.2.1 - Paging, segmentation and virtual memoryA running program uses addresses without having to know exactly where all its data sits in physical RAM. You will follow how the OS allocates and protects memory, compare fixed-size pages with logical segments, and trace pages moving between RAM and secondary storage. This explains both the usefu...
1.2.1 - Interrupts and processor schedulingA CPU must respond to events while sharing its time between running programs. You will follow an interrupt through a saved processor state, then compare five scheduling policies using complete small traces. The timing assumptions matter: a different arrival time or preemption rule can change the...
1.2.1 - Operating-system types and virtual machinesOperating systems can be classified by how they share resources, where they run and what timing they promise. You will apply five overlapping categories to real needs, then compare a virtual computer that runs a guest OS with a runtime that executes intermediate code. These distinctions help expl...
1.2.2 - Applications, utilities and source licensingChoosing software begins with the job it must do, rather than a familiar product name. You will distinguish applications from utilities, justify useful features for particular users, and weigh open and closed source from both the user's and the creator's perspective.
1.2.2 - Translators, libraries, linkers and loadersA processor executes machine instructions, while programmers often write in a more readable language. You will follow how translators bridge that gap, why reusable libraries are helpful, and how linking and loading prepare translated code to run.
1.2.2 - The stages of compilationCompilation changes a written program into target instructions through several representations. You will follow tokens, grammatical structure, code generation and optimisation, and distinguish a translation error from a program that runs but gives the wrong result.
1.2.3 - Software-development methodsSoftware development must turn a changing human need into a working, maintainable system. You will compare waterfall, agile, extreme programming, spiral and rapid application development by following what each does with requirements, feedback and risk.
1.2.3 - Writing and following algorithmsAn algorithm makes the steps of a solution precise enough to follow. You will build solutions from sequence, decisions and loops, read OCR pseudocode and flowcharts, and trace changing values rather than guess a final output.
1.2.4 - Programming paradigms and procedural codeA programming paradigm offers a way to organise a solution. You will compare the reasons for different approaches, then build procedural programs using values, expressions, input, strings and subroutines with explicit data flow.
1.2.4 - Little Man Computer programsLittle Man Computer makes a program's storage and control decisions visible. You will follow the accumulator, write arithmetic and branch instructions, and check that a small assembly program produces the intended output.
1.2.4 - Immediate, direct, indirect and indexed addressingAn instruction's operand may be the data itself or information used to locate the data. You will distinguish four addressing modes, calculate effective addresses, and follow explicitly defined assembly notation without assuming every machine supports the same modes.
1.2.4 - Object-oriented programming principlesObject-oriented programming groups state with the operations that use it. You will distinguish a class from its objects, protect an object's state through methods, and follow how inheritance and overriding affect a method call in OCR pseudocode and Python.

Exchanging data

1.3.1 - Lossy and lossless compressionA smaller representation can reduce storage use and the time needed to transmit a file. You will see when the original information can be reconstructed exactly, then encode and decode small examples using run-length encoding and dictionary coding.
1.3.1 - Encryption and hashingA system may need to keep data unreadable to an intruder, or check whether an input matches an earlier value without retrieving that value. You will follow how keys make encryption reversible, then see why hashing answers a different question.
1.3.2 - Relational databases, keys and relationshipsA lending club needs to store members, equipment and loans without confusing one person or item with another. You will organise these facts into linked tables, read the relationships between them, and choose ways to capture and exchange the data.
1.3.2 - Normalisation and referential integrityRepeated facts can make a database contradict itself when records change. You will reorganise an order table through first, second and third normal form, using stated dependencies to decide which facts belong together, then protect the links between the resulting tables.
1.3.2 - SQL selection, joins and nested queriesSQL lets you ask a precise question of linked records without manually searching every row. You will select columns and rows, combine conditions, match text patterns, and use joins and nested queries on a complete lending-club dataset.
1.3.2 - SQL data changes and database indexingQueries retrieve records, but database users also need to add data, remove it and sometimes remove a whole table. You will follow these different changes in a small workshop database, then see how an index can speed a search while adding maintenance work.
1.3.2 - Transactions, ACID and record lockingSeveral individually valid changes can still leave a database wrong if a process fails halfway through or two users overwrite each other. You will treat a booking as one transaction, explain the four ACID properties, and trace how locking and recovery protect shared data.
1.3.3 - Internet structure, protocols and switchingA web request can cross several networks while the browser treats it as one conversation. This lesson explains how shared rules, addresses and layers make that possible, and why sharing a route in packets has different consequences from reserving a circuit.
1.3.3 - Network threats, firewalls and proxiesConnecting a system creates routes for useful communication and for attacks. This lesson follows the mechanisms behind common threats, then explains how firewalls, proxies, encryption and other controls reduce particular risks while leaving limits that still need attention.
1.3.3 - Network hardware and architecturesA network needs connections, forwarding devices and an arrangement for providing services. This lesson distinguishes those jobs and uses small organisations to show why a physical layout and a client-server or peer-to-peer architecture are separate choices.
1.3.4 - HTML structure and CSS stylingHTML describes a page's structure and meaning; CSS controls its presentation. You will read and amend the required elements, attributes and styling rules, then use an ordinary local editor and browser to practise writing real pages.
1.3.4 - JavaScript and client-server processingJavaScript can process form input and change a page in the browser. You will follow its procedural structures, trace visible state and outputs, and decide which work belongs on a client or a server; writing practice uses a local editor and browser.
1.3.4 - Search indexing and PageRankA search engine prepares information about pages before you enter a query. This lesson follows discovery and indexing, then explains how a page's incoming links can contribute to its importance without confusing that link score with relevance or the whole modern ranking system.

Data types, structures and Boolean logic

1.4.1 - Primitive data types and character setsA value such as 007 might be an identifier, a number to calculate with, or three characters to display. This part of 1.4.1 explains how data types give values meaning and how ASCII and Unicode let computers store text as binary. You will choose types for a purpose, convert input deliberately, and...
1.4.1 - Binary, hexadecimal and denaryThe bit pattern 00101101 can be written much more compactly as 2D in hexadecimal without changing its value. This part of 1.4.1 develops positive integer representations in binary, hexadecimal and denary, then converts between every pair. You will use place values and bit grouping to explain the...
1.4.1 - Signed binary and integer arithmeticAn eight-bit pattern can mean a positive unsigned integer or a negative signed integer, depending on its interpretation. This part of 1.4.1 compares sign and magnitude with two's complement, then uses fixed-width binary addition and subtraction. You will distinguish a discarded carry from signed...
1.4.1 - Floating-point representation and normalisationThe same fixed collection of bits can represent a small fraction or a large value if a separate exponent scales it. This part of 1.4.1 builds binary fractions, interprets signed mantissas and exponents, and normalises positive and negative floating-point values. Every calculation states its forma...
1.4.1 - Floating-point arithmeticAdding floating-point bit patterns requires more than adding the two mantissa fields. This part of 1.4.1 shows why exponents must be aligned, how signed mantissas are added or subtracted, and how the result is normalised. You will also explain when limited precision or exponent range prevents an...
1.4.1 - Bitwise operations, shifts and masksA byte can store eight independent flags rather than one number. This part of 1.4.1 applies AND, OR and XOR to individual bits, builds masks to select or change flags, and follows left and right logical shifts. You will keep the bit width explicit and explain when a shift's numeric interpretation...
1.4.2 - Arrays, records, lists and tuplesA booking program needs to store seat availability, details of each booking, and an ordered collection of bookings. These are different jobs. You will choose a suitable structure, interpret arrays with up to three indices, and follow the actual steps needed to create, traverse, insert and remove...
1.4.2 - Linked lists and pointer operationsIn an array, neighbouring list positions are usually represented by neighbouring indices. A linked list keeps its order in links instead. You will follow that order, create nodes, and change pointers without losing the rest of the list, including at its boundaries.
1.4.2 - Stacks, queues and circular buffersUndo history should return the latest action first, while a printer normally processes the earliest waiting job first. These different removal rules lead to stacks and queues. You will implement their operations, trace their state, and handle the limits of fixed storage without changing the promi...
1.4.2 - Trees and binary search treesA folder hierarchy and an ordered index both use linked nodes, but they obey different rules. You will build and change rooted trees, use the ordering rule of a binary search tree, and trace the order in which its nodes are visited.
1.4.2 - Directed and undirected graphsA transport link and a one-way dependency need different relationships. You will represent directed and undirected graphs, keep their adjacency data consistent when they change, and traverse safely when cycles or disconnected vertices occur.
1.4.2 - Hash tables and collision handlingA hash table uses a key to choose where a record should be stored, but different keys can choose the same place. You will create tables, resolve those collisions, and preserve the search rules when inserting, finding and deleting records.
1.4.3 - Boolean problems, gates and truth tablesBoolean logic turns a precise two-state decision into an expression, a circuit and a table of every possible outcome. You will learn to move between these representations while checking that they describe the same rule.
1.4.3 - Boolean laws and simplificationA shorter Boolean expression can implement exactly the same decision with fewer operations. You will justify each transformation using a valid law, handle negated groups carefully, and check that simplification preserves every input outcome.
1.4.3 - Karnaugh mapsA Karnaugh map places truth-table results so that adjacent cells differ in one input. You will use that arrangement to find groups, remove changing variables, and derive a simpler expression with the same outputs.
1.4.3 - Adders and D-type flip-flopsLogic gates can calculate the bits of a sum, while clocked storage retains a bit for later use. You will derive half and full adders, connect carry between bit positions, and trace the behaviour of a D-type flip-flop at explicitly stated clock edges.

Legal, moral, cultural and ethical issues

1.5.1 - Data protection and personal informationPersonal information lets organisations provide useful services, but misuse can expose or disadvantage the people described. Learn who is responsible for that information, apply the historical rules named by OCR, and distinguish them from the current UK framework.
1.5.1 - Computer misuse, copyright and interceptionDifferent computing laws protect different interests: authorised access, creative ownership and controlled investigation. Apply each law to the action in a scenario, keeping legal permission separate from whether an action is ethically justified.
1.5.2 - Workforce changes and automated decisionsAutomation changes who performs a task, while AI can change how a decision is reached. Explain the effects on workers and people subject to decisions, examine errors and bias, and justify safeguards using the actual consequences of a system.
1.5.2 - Privacy, censorship and online conductDigital communication can widen access to information while making behaviour easier to record, analyse and control. Examine who gains, who may be harmed and how a targeted safeguard changes the trade-off in a particular service.
1.5.2 - Environmental and cultural design choicesA computing product affects resources throughout its life and reaches people with different languages, abilities and conventions. Use those effects to justify choices about equipment, energy, disposal, layout, colour and text representation.

Algorithms and programming (02)

Elements of computational thinking

2.1.1 - Abstraction and modelsA program cannot represent every detail of the world. You will choose the details that matter to a particular problem, build a model from them, and recognise when its simplifying assumptions stop being useful.
2.1.2 - Inputs, outputs and preconditionsBefore choosing an algorithm, make its problem precise. You will identify the data a solution needs, the form of its results, and the conditions that must hold before it starts.
2.1.2 - Caching and reusable componentsThinking ahead can save repeated work. You will decide when a computed result can be cached, when it becomes stale, and when a tested program component can serve several callers.
2.1.3 - Decomposition and procedural plansA large task becomes manageable when its responsibilities, interfaces and ordering are clear. You will break a computational problem into components, organise a solution, and identify subprocedures that can be tested and reused.
2.1.4 - Logical decisions and control flowAn algorithm's route depends on the conditions it tests. You will locate decisions, translate requirements into precise Boolean conditions, and follow how true and false outcomes change the program's state and output.
2.1.5 - Concurrent thinking and dependenciesSome work can overlap, while other work must wait for data or shared resources. You will identify independence, plan a schedule under stated assumptions, and judge the benefits and costs of concurrent processing in a concrete program.

Problem solving and programming

2.2.1 - Sequence, selection and iterationA program becomes useful when its instructions can choose and repeat actions as well as execute them in order. You will combine these constructs, trace their changing state and recognise the differences between OCR pseudocode and Python. Small boundary cases will help you find errors that an ordi...
2.2.1 - Recursion and iterationSome problems can be solved by reducing them to a smaller version of the same problem. You will follow recursive calls down to a stopping case and follow their returned values back out. Comparing the same calculation with a loop will reveal when recursion helps and what its saved calls cost.
2.2.1 - Scope, subroutines and parameter passingA subroutine needs a clear way to receive data, produce results and control which state it can change. You will use local and global variables, distinguish functions from procedures, and trace value and reference parameters. Python examples will show why sharing an object is different from giving...
2.2.1 - Files and persistent recordsA file lets records survive after a program finishes. You will read complete text files, distinguish a blank line from the end of a file, write a new result safely, and put file processing behind a clear function interface. OCR pseudocode and Python express these operations differently.
2.2.1 - IDE tools and systematic debuggingAn integrated development environment brings editing, execution and diagnostic tools into one workspace. You will distinguish different kinds of fault and use breakpoints, stepping and variable inspection to locate the first incorrect operation. A passing example run is evidence to extend, not pr...
2.2.1 - Designing and implementing object-oriented solutionsAn object-oriented design becomes useful when its classes can be constructed, called and traced correctly. You will turn a small scenario and class diagram into attributes and instance methods, protect state through an interface, and implement inherited behaviour with overriding. Python and OCR p...
2.2.2 - Recognising computational problemsBefore writing an algorithm, decide what problem it is supposed to solve. You will turn a messy description into a precise computational task, separate its responsibilities and keep only the information needed by a useful model.
2.2.2 - Divide and conquerDividing a problem can expose smaller instances that can be solved using the same rule. You will trace the split, solve and combine stages, implement a small recursive solution and decide which work can safely overlap.
2.2.2 - BacktrackingA promising choice can lead to a dead end. You will follow how backtracking restores an earlier state, tries another possibility and finds a solution without retaining choices that have failed.
2.2.2 - Data mining and heuristicsLarge datasets can reveal relationships that a person would miss, and a useful rule can guide a search without examining every possibility. You will distinguish evidence from certainty, interrogate a small sample and implement a simple heuristic whose limitations you can demonstrate.
2.2.2 - Performance modelling, pipelines and visualisationA model can predict a design's cost before a complete system is built. You will calculate a bounded performance prediction, follow data through a software pipeline and use representations of state and timing to anticipate behaviour and diagnose limits.

Algorithms

2.3.1 - Algorithm design and suitabilityA useful algorithm must solve the stated problem for all permitted inputs, then fit the task's resource limits. You will turn a requirement into steps, express those steps in three representations, trace and test them, and justify a choice using the actual data and workload.
2.3.1 - Algorithm efficiency and Big OAn algorithm's resource needs depend on both the amount of data and the operations it performs. You will derive growth from steps, distinguish cases, read complexity graphs, and compare time with auxiliary memory under explicit assumptions.
2.3.1 - Data-structure algorithms and tree traversalA structure is useful only when its operations preserve the required relationships. You will connect stack, queue, linked-list and tree algorithms to their invariants, then implement and trace postorder depth-first and breadth-first traversals under a clear node contract.
2.3.1 - Bubble sort and insertion sortSorting puts items into an agreed order while retaining every item. You will follow two ways to build ascending order, implement them with safe bounds, and explain why their work depends on the initial order of the data.
2.3.1 - Merge sort and quicksortMerge sort orders small sublists while combining them; quicksort partitions around a pivot before sorting the smaller regions. You will trace and implement both, specify what happens to equal keys, and compare time and memory under stated assumptions.
2.3.1 - Linear and binary searchA search must distinguish an item at index 0 from an item that is absent. You will trace sequential and interval-based searching, implement safe stopping rules, and choose a method from the ordering, access and duplicate requirements of the data.
2.3.1 - Dijkstra's shortest-path algorithmA route with the fewest links need not have the lowest cost. You will use Dijkstra's algorithm to keep track of the cheapest routes found so far, decide when a cost is final and recover the actual path. The edge weights, direction and tie rules will be explicit throughout.
2.3.1 - A-star search and heuristicsA combines the cost already spent with an estimate of the cost still needed. You will trace its open and closed sets, explain why a promising route is selected and identify the assumptions that let it return a shortest path. A useful estimate can save work, but its quality and the handling of rev...

Programming project skills (03)

Analysis of the problem

3.1.1 - Formative project skills: choosing a computational problemA promising computing problem has more than a topic: it has information that can be represented and decisions that a program can carry out. You will practise explaining computational suitability, choosing a manageable scope and recognising the evidence and tooling needed for a project. Every exam...
3.1.2 - Formative project skills: stakeholder needsA solution can function correctly and still fail the people who need it. You will practise identifying stakeholders, finding evidence of their needs and explaining why particular solution choices fit those needs. All examples and activities are formative project-skills practice, rather than asses...
3.1.3 - Formative project skills: researching solutionsResearch is useful when it helps you choose an approach and explain its consequences. You will practise comparing possible solutions, justifying essential features and stating honest limits on an original miniature problem. Every example and activity is formative project-skills practice and suppl...
3.1.4 - Formative project skills: requirements and success criteriaRequirements say what a proposed solution must provide; measurable success criteria make it possible to judge how well it provides it. You will practise writing precise behaviours, justifying an appropriate configuration and planning evidence for a conclusion. All cases and activities are formati...

Design of the solution

3.2.1 - Formative project skills: decomposing a solutionDecomposition turns a large problem into parts whose responsibilities and connections can be understood. You will practise choosing useful boundaries, specifying the information between parts and justifying how the parts cover the problem. All examples and activities are formative project-skills...
3.2.2 - Formative project skills: structure and algorithmsA list of modules cannot explain how a solution works. You will practise connecting responsibilities through precise contracts and algorithms, then justify whether the connections cover a small problem. All examples and checks are formative project-skills practice, not an assessed H446/03 project...
3.2.2 - Formative project skills: usability, data and validationA usable interface helps someone enter the right information and understand what happened. You will practise justifying interface features, data choices and validation for small fictional systems. These activities develop design skills; they do not complete, authenticate or grade your assessed H4...
3.2.3 - Formative project skills: designing test dataA test is useful when its input can reveal a particular mistake and its expected result is known. You will practise justifying data for both development iterations and the completed solution. These fictional plans and checks are formative project-skills practice; they are not evidence that your o...

Evaluation

3.4.1 - Formative project skills: robustness and usability testingA final product needs evidence about difficult operating conditions and about people using its interface. These original formative cases teach how to test robustness and collect useful user feedback after development. They practise project skills; they are not a completed or authenticated H446/03...
3.4.2-3.4.3 - Formative project skills: evaluating the final productEvaluation explains how far a solution meets its original needs and how the evidence supports that judgement. These original formative cases connect developmental and final tests to success criteria, assess usability features, and practise clear, authentic reporting. Your own assessed project mus...
3.4.4 - Formative project skills: maintenance and further developmentA working version will still face faults, changing needs and unfamiliar maintainers. These original formative cases teach how to evaluate maintainability and propose justified further development, using evidence, risks and a concrete verification plan. They do not constitute an assessed programmi...