Explore
A-LevelOCR
Computer Science
Start learning
Browse allCurriculum Modules
The Fetch-Decode-Execute CycleCPU Components and Their FunctionsRISC vs. CISC ArchitectureFactors Affecting CPU PerformanceInput, Output, and Storage DevicesPrimary vs. Secondary Storage: A ComparisonOffline Storage DevicesCache Memory and Its ImportanceThe Role of Registers in the CPUBuses and Their Role in Computer ArchitectureKnowledge Check: Summary & Quizzes
Operating Systems (OS) and Their FunctionsUtility Programs and System MaintenanceGeneral-Purpose vs. Bespoke SoftwareWaterfall Model: A Step-by-Step GuideAgile Development Methodology ExplainedExtreme Programming (XP) PrinciplesHigh-Level and Low-Level LanguagesLanguage TranslatorsIntegrated Development Environments (IDEs)Knowledge Check: Summary & Quizzes
What the CPU Does: The Stored Program ConceptCPU Components: ALU, Control Unit, Registers and BusesKey Registers: PC, MAR, MDR, ACC and Status RegisterThe Fetch–Decode–Execute Cycle Step-by-StepHow Instructions and Data Move Around the Von Neumann ModelVon Neumann vs Harvard ArchitectureInterrupts: Why They Exist and What They EnableInterrupt Handling: ISR, Interrupt Vector and Context SwitchingPolling vs InterruptsCPU Performance Factors: Clock Speed, Cores, Cache and Instruction SetThe Role of Cache and Why It Improves PerformancePipelining: How It Works and Why It HelpsPipeline Hazards and How They Reduce Speed-UpRISC vs CISC: Trade-Offs and Use CasesGPUs: Why They’re Different from CPUsMulticore vs Parallel Processing: Key Ideas and ExamplesInput Devices: Sensors, Human Input and Embedded InputsOutput Devices: Displays, Actuators and Control OutputsStorage Types: Magnetic, Optical and Solid-StateRAM vs ROM: Purpose, Characteristics and UseVirtual Memory: Why It Exists and the Performance Cost
What Systems Software Is and Why It MattersOperating System Core Functions: UI, File, Device and Resource ManagementProcess Management: Processes, Threads and MultitaskingMemory Management: Allocation, Protection and Virtual MemoryPaging and the Idea of a Page TableSystem Interrupts: Sources and OS ResponseScheduling Goals: Throughput, Responsiveness and FairnessScheduling Algorithms: FCFS, SJF and Round RobinTypes of Operating System: Batch, Multi-User, Real-Time and EmbeddedBIOS and the Boot ProcessDevice Drivers: Purpose and How They Enable Hardware AbstractionVirtual Machines: How They Work and Why They’re UsedApplication Software vs Utility SoftwareOpen Source vs Closed Source: Licensing and Development ImplicationsTranslators: Assembler vs Compiler vs InterpreterStages of Compilation: Lexing, Parsing, Code Generation and OptimisationLibraries: Why We Use Them and How They Speed DevelopmentLinkers and Loaders: From Object Code to Running ProgramWaterfall Model: Phases, Strengths and WeaknessesAgile Development: Iteration, User Stories and Continuous FeedbackSpiral Model: Risk-Driven IterationRapid Application Development: Prototyping and User InvolvementChoosing a Development Methodology for a ScenarioProgramming Paradigms: Procedural, OOP and Declarative OverviewAssembly Language: Why Low-Level Still MattersLittle Man Computer: Modelling Machine-Level ExecutionAddressing Modes: Immediate, Direct, Indirect and Indexed
Lossless vs Lossy Compression: When Each Is AppropriateRun Length Encoding: Encoding and Decoding Worked ExamplesDictionary Coding: Building a Dictionary and Representing DataWhy Compression Works: Redundancy and PatternsSymmetric Encryption: Keys, Speed and Typical UsesAsymmetric Encryption: Public/Private Keys and Typical UsesKey Exchange and Real-World Secure CommunicationHashing: What a Hash Is and What It’s ForHashing Uses: Integrity Checking, Password Storage and VerificationRelational Databases: Tables, Rows, Columns and KeysPrimary Keys, Foreign Keys and RelationshipsEntity Relationship Diagrams: Entities, Attributes and CardinalityDesigning a Database Schema from a ScenarioNormalisation: Why We Do It (Redundancy and Anomalies)First Normal Form: Removing Repeating GroupsSecond Normal Form: Removing Partial DependenciesThird Normal Form: Removing Transitive DependenciesSQL Basics: SELECT, WHERE, ORDER BY and AggregatesSQL Joins: Why They’re Needed and How They WorkData Validation vs Verification in Data CaptureCapturing and Selecting Data: Sampling, Bias and Data QualityTransaction Processing: What It Is and Why It MattersACID Properties: What Each One Protects AgainstNetworks: LAN vs WAN and Typical FeaturesClient–Server vs Peer-to-Peer: Strengths and WeaknessesTCP/IP Model: Layers and What Happens at EachIP Addressing and Routing: Core IdeasDNS: Why It Exists and How a Lookup WorksPacket vs Circuit Switching: Comparing How Data MovesNetwork Hardware: Switches, Routers, WAPs and NICsNetwork Threats: Malware, Phishing, Man-in-the-Middle and DoSNetwork Security Controls: Firewalls, Encryption and AuthenticationSearch Engine Indexing: Crawling, Indexing and RetrievalPage Ranking: Why Ordering Results Is HardServer-Side vs Client-Side ProcessingHTML Structure: Elements, Attributes and Semantic LayoutCSS: Selectors and Styling RulesJavaScript Basics: Variables, Selection and IterationJavaScript Functions: Parameters and Return Values
Primitive Data Types: Integer, Real, Boolean and CharacterBinary Place Value and Converting to DecimalRepresenting Positive Integers in BinaryTwo’s Complement: Representing Negative IntegersRange, Overflow and What Happens When It BreaksBinary Addition Worked ExamplesBinary Subtraction Worked ExamplesHexadecimal: Converting and Why It’s UsefulFloating Point Representation: Mantissa and ExponentFloating Point Precision and Rounding ErrorFloating Point Arithmetic: Common PitfallsBitwise Operations: AND, OR, XOR and NOTBit Shifts and Their UsesMasks: Setting, Clearing and Testing BitsCharacter Sets: ASCII vs UnicodeArrays: Indexing, Traversal and Common OperationsRecords, Lists and Tuples: When Each Fits BestLinked Lists: Nodes, Pointers and TraversalLinked List Operations: Insert and DeleteStacks: LIFO and Push/Pop OperationsQueues: FIFO and Enqueue/Dequeue OperationsGraphs: Vertices, Edges and RepresentationsAdjacency Matrix vs Adjacency ListGraph Traversal: Visiting and Tracking StateTrees: Root, Parent/Child, Leaf and HeightTree Traversal: Preorder, Inorder and PostorderBinary Search Trees: Ordering Rules and SearchBST Operations: Insert and DeleteHash Tables: Hash Functions and CollisionsCollision Handling: Chaining vs Open AddressingBoolean Logic: Operators and Truth TablesLaws of Boolean Algebra and SimplificationDe Morgan’s Laws in Logic ExpressionsKarnaugh Maps: Simplifying Boolean ExpressionsFlip-Flops: SR, D and JK as Memory ElementsRegisters and Counters from Flip-FlopsHalf Adder vs Full AdderRipple Carry Adders: How Multi-Bit Addition Works
Why Computing Raises Legal and Ethical ChallengesThe Data Protection Act 1998: Key Principles and ResponsibilitiesData Controllers and Data Subjects: Roles and DutiesThe Computer Misuse Act 1990: Core Offences and ExamplesThe Copyright, Designs and Patents Act 1988: Protecting Software and MediaLicensing: What You Can and Can’t Do with SoftwareThe Regulation of Investigatory Powers Act 2000: Monitoring and InterceptionArtificial Intelligence: Benefits, Risks and AccountabilityBias in Automated Systems: Where It Comes FromAutomated Decision-Making: Transparency and AppealCensorship and The Internet: Competing InterestsMonitoring Behaviour Online: Tracking, Cookies and ConsentAnalysing Personal Information: Profiling and InferencePiracy: Impacts on Creators, Users and IndustryOffensive Communications: Harm, Responsibility and EnforcementAccessibility: Layout, Colour Choices and Inclusive DesignComputers in the Workforce: Job Change, Deskilling and UpskillingEnvironmental Effects: Energy Use, E-Waste and Sustainability
What Computational Thinking Is (and Isn’t)Abstraction: Removing Detail to Focus on the EssentialsChoosing What to Abstract: Fitness for PurposeModels and Simulations: When Abstractions Become ToolsThinking Ahead: Anticipating Inputs, Outputs and Edge CasesPreconditions and Postconditions in a SolutionThinking Procedurally: Defining Clear StepsDecomposition: Splitting Problems into Sub-ProblemsIdentifying Sub-Procedures and Reuse OpportunitiesThinking Logically: Building Conditions That Are CorrectBoolean Conditions: AND/OR/NOT in Problem SolvingTraceability: Following Logic Through a ProgramThinking Concurrently: Doing More Than One Thing at OnceConcurrency vs Parallelism: The Key DifferenceRace Conditions and Why Order Matters
From Problem Statement to RequirementsInput–Process–Output as a Starting FrameworkSelecting Data Types for a ProblemArithmetic, Logical and Boolean Operators in CodeSequence, Selection and Iteration in Real ProgramsNested Selection and Nested LoopsWriting Modular Code with Functions and ProceduresDesigning Clear Function InterfacesParameter Passing: By Value vs By ReferenceScope: Global vs Local VariablesRecursion: Base Case, Recursive Case and Stack BehaviourWhen Recursion Beats Iteration (and When It Doesn’t)Defensive Programming: Validation and Error HandlingUsing an IDE: Breakpoints, Watches and Step-Through DebuggingDebugging Strategies: Tracing, Logging and Unit TestsOOP in Practice: Defining and Using ClassesObjects, Methods and Attributes in CodeEncapsulation: Protecting State with Access ControlInheritance: Reuse and SpecialisationPolymorphism: Interfaces and OverridingProblem Recognition: Identifying the Real TaskProblem Decomposition: Structuring a Large SolutionDivide and Conquer: Splitting Work RecursivelyBacktracking: Searching with UndoHeuristics: “Good Enough” Strategies for Hard ProblemsData Mining Concepts: Patterns, Trends and UsesPerformance Modelling: Estimating Time/Space NeedsVisualisation: Using Diagrams to Understand a System
What Makes an Algorithm “Suitable” for a TaskCorrectness: Proving or Testing an Algorithm WorksMeasuring Complexity: Time vs SpaceBig O Notation: What It Describes (and What It Doesn’t)Best, Average and Worst Case ComplexityLinear Search: Step-by-Step TraceBinary Search: Preconditions and TraceBubble Sort: How It Works and Why It’s SlowInsertion Sort: When It’s a Good ChoiceMerge Sort: Divide, Merge and ComplexityQuick Sort: Partitioning and Performance Trade-OffsChoosing a Sort for a ScenarioDijkstra’s Algorithm: Shortest Path with Non-Negative WeightsTracing Dijkstra’s Algorithm on a GraphA* Algorithm: Heuristics and Informed SearchComparing Dijkstra vs A*Stack Algorithms: Valid Push/Pop SequencesQueue Algorithms: Simulating Enqueue/DequeueLinked List Algorithms: Traversal, Insert and DeleteTree Algorithms: Traversal and SearchingBST Algorithms: Insert, Search and Delete Traces
Picking a Problem That Is Suitable for OCR NEAStakeholders, Users and Clear Problem DefinitionInvestigating Existing Solutions and Setting Success CriteriaRequirements: Functional vs Non-FunctionalAnalysing Inputs, Outputs, Data and ConstraintsDesigning a Solution: Top-Down Design and DecompositionDesigning Data Structures for Your SolutionDesigning Algorithms for Key FeaturesUI/UX Design (Where Relevant): Layout and AccessibilityPlanning Development: Milestones and IterationsVersion Control Basics for NEA EvidenceBuilding a Test Strategy: Unit, Integration and System TestsWriting a Test Plan with Expected OutcomesDebugging Evidence: Showing How Issues Were Found and FixedEvaluating Against Success CriteriaLimitations, Improvements and Future WorkDocumentation That Gets Credit: What to Include and How to Present ItConsidering Legal, Ethical and Security Implications in Your Project
