Explore
A-LevelOCR
Computer Science
Exam Questions
The Fetch-Decode-Execute CycleNewCPU Components and Their FunctionsNewRISC vs. CISC ArchitectureNewFactors Affecting CPU PerformanceNewInput, Output, and Storage DevicesNewPrimary vs. Secondary Storage: A ComparisonNewOffline Storage DevicesNewCache Memory and Its ImportanceNewThe Role of Registers in the CPUNewBuses and Their Role in Computer ArchitectureNewKnowledge Check: Summary & QuizzesNew
Operating Systems (OS) and Their FunctionsNewUtility Programs and System MaintenanceNewGeneral-Purpose vs. Bespoke SoftwareNewWaterfall Model: A Step-by-Step GuideNewAgile Development Methodology ExplainedNewExtreme Programming (XP) PrinciplesNewHigh-Level and Low-Level LanguagesNewLanguage TranslatorsNewIntegrated Development Environments (IDEs)NewKnowledge Check: Summary & QuizzesNew
What the CPU Does: The Stored Program ConceptNewCPU Components: ALU, Control Unit, Registers and BusesNewKey Registers: PC, MAR, MDR, ACC and Status RegisterNewThe Fetch–Decode–Execute Cycle Step-by-StepNewHow Instructions and Data Move Around the Von Neumann ModelNewVon Neumann vs Harvard ArchitectureNewInterrupts: Why They Exist and What They EnableNewInterrupt Handling: ISR, Interrupt Vector and Context SwitchingNewPolling vs InterruptsNewCPU Performance Factors: Clock Speed, Cores, Cache and Instruction SetNewThe Role of Cache and Why It Improves PerformanceNewPipelining: How It Works and Why It HelpsNewPipeline Hazards and How They Reduce Speed-UpNewRISC vs CISC: Trade-Offs and Use CasesNewGPUs: Why They’re Different from CPUsNewMulticore vs Parallel Processing: Key Ideas and ExamplesNewInput Devices: Sensors, Human Input and Embedded InputsNewOutput Devices: Displays, Actuators and Control OutputsNewStorage Types: Magnetic, Optical and Solid-StateNewRAM vs ROM: Purpose, Characteristics and UseNewVirtual Memory: Why It Exists and the Performance CostNew
What Systems Software Is and Why It MattersNewOperating System Core Functions: UI, File, Device and Resource ManagementNewProcess Management: Processes, Threads and MultitaskingNewMemory Management: Allocation, Protection and Virtual MemoryNewPaging and the Idea of a Page TableNewSystem Interrupts: Sources and OS ResponseNewScheduling Goals: Throughput, Responsiveness and FairnessNewScheduling Algorithms: FCFS, SJF and Round RobinNewTypes of Operating System: Batch, Multi-User, Real-Time and EmbeddedNewBIOS and the Boot ProcessNewDevice Drivers: Purpose and How They Enable Hardware AbstractionNewVirtual Machines: How They Work and Why They’re UsedNewApplication Software vs Utility SoftwareNewOpen Source vs Closed Source: Licensing and Development ImplicationsNewTranslators: Assembler vs Compiler vs InterpreterNewStages of Compilation: Lexing, Parsing, Code Generation and OptimisationNewLibraries: Why We Use Them and How They Speed DevelopmentNewLinkers and Loaders: From Object Code to Running ProgramNewWaterfall Model: Phases, Strengths and WeaknessesNewAgile Development: Iteration, User Stories and Continuous FeedbackNewSpiral Model: Risk-Driven IterationNewRapid Application Development: Prototyping and User InvolvementNewChoosing a Development Methodology for a ScenarioNewProgramming Paradigms: Procedural, OOP and Declarative OverviewNewAssembly Language: Why Low-Level Still MattersNewLittle Man Computer: Modelling Machine-Level ExecutionNewAddressing Modes: Immediate, Direct, Indirect and IndexedNew
Lossless vs Lossy Compression: When Each Is AppropriateNewRun Length Encoding: Encoding and Decoding Worked ExamplesNewDictionary Coding: Building a Dictionary and Representing DataNewWhy Compression Works: Redundancy and PatternsNewSymmetric Encryption: Keys, Speed and Typical UsesNewAsymmetric Encryption: Public/Private Keys and Typical UsesNewKey Exchange and Real-World Secure CommunicationNewHashing: What a Hash Is and What It’s ForNewHashing Uses: Integrity Checking, Password Storage and VerificationNewRelational Databases: Tables, Rows, Columns and KeysNewPrimary Keys, Foreign Keys and RelationshipsNewEntity Relationship Diagrams: Entities, Attributes and CardinalityNewDesigning a Database Schema from a ScenarioNewNormalisation: Why We Do It (Redundancy and Anomalies)NewFirst Normal Form: Removing Repeating GroupsNewSecond Normal Form: Removing Partial DependenciesNewThird Normal Form: Removing Transitive DependenciesNewSQL Basics: SELECT, WHERE, ORDER BY and AggregatesNewSQL Joins: Why They’re Needed and How They WorkNewData Validation vs Verification in Data CaptureNewCapturing and Selecting Data: Sampling, Bias and Data QualityNewTransaction Processing: What It Is and Why It MattersNewACID Properties: What Each One Protects AgainstNewNetworks: LAN vs WAN and Typical FeaturesNewClient–Server vs Peer-to-Peer: Strengths and WeaknessesNewTCP/IP Model: Layers and What Happens at EachNewIP Addressing and Routing: Core IdeasNewDNS: Why It Exists and How a Lookup WorksNewPacket vs Circuit Switching: Comparing How Data MovesNewNetwork Hardware: Switches, Routers, WAPs and NICsNewNetwork Threats: Malware, Phishing, Man-in-the-Middle and DoSNewNetwork Security Controls: Firewalls, Encryption and AuthenticationNewSearch Engine Indexing: Crawling, Indexing and RetrievalNewPage Ranking: Why Ordering Results Is HardNewServer-Side vs Client-Side ProcessingNewHTML Structure: Elements, Attributes and Semantic LayoutNewCSS: Selectors and Styling RulesNewJavaScript Basics: Variables, Selection and IterationNewJavaScript Functions: Parameters and Return ValuesNew
Primitive Data Types: Integer, Real, Boolean and CharacterNewBinary Place Value and Converting to DecimalNewRepresenting Positive Integers in BinaryNewTwo’s Complement: Representing Negative IntegersNewRange, Overflow and What Happens When It BreaksNewBinary Addition Worked ExamplesNewBinary Subtraction Worked ExamplesNewHexadecimal: Converting and Why It’s UsefulNewFloating Point Representation: Mantissa and ExponentNewFloating Point Precision and Rounding ErrorNewFloating Point Arithmetic: Common PitfallsNewBitwise Operations: AND, OR, XOR and NOTNewBit Shifts and Their UsesNewMasks: Setting, Clearing and Testing BitsNewCharacter Sets: ASCII vs UnicodeNewArrays: Indexing, Traversal and Common OperationsNewRecords, Lists and Tuples: When Each Fits BestNewLinked Lists: Nodes, Pointers and TraversalNewLinked List Operations: Insert and DeleteNewStacks: LIFO and Push/Pop OperationsNewQueues: FIFO and Enqueue/Dequeue OperationsNewGraphs: Vertices, Edges and RepresentationsNewAdjacency Matrix vs Adjacency ListNewGraph Traversal: Visiting and Tracking StateNewTrees: Root, Parent/Child, Leaf and HeightNewTree Traversal: Preorder, Inorder and PostorderNewBinary Search Trees: Ordering Rules and SearchNewBST Operations: Insert and DeleteNewHash Tables: Hash Functions and CollisionsNewCollision Handling: Chaining vs Open AddressingNewBoolean Logic: Operators and Truth TablesNewLaws of Boolean Algebra and SimplificationNewDe Morgan’s Laws in Logic ExpressionsNewKarnaugh Maps: Simplifying Boolean ExpressionsNewFlip-Flops: SR, D and JK as Memory ElementsNewRegisters and Counters from Flip-FlopsNewHalf Adder vs Full AdderNewRipple Carry Adders: How Multi-Bit Addition WorksNew
Why Computing Raises Legal and Ethical ChallengesNewThe Data Protection Act 1998: Key Principles and ResponsibilitiesNewData Controllers and Data Subjects: Roles and DutiesNewThe Computer Misuse Act 1990: Core Offences and ExamplesNewThe Copyright, Designs and Patents Act 1988: Protecting Software and MediaNewLicensing: What You Can and Can’t Do with SoftwareNewThe Regulation of Investigatory Powers Act 2000: Monitoring and InterceptionNewArtificial Intelligence: Benefits, Risks and AccountabilityNewBias in Automated Systems: Where It Comes FromNewAutomated Decision-Making: Transparency and AppealNewCensorship and The Internet: Competing InterestsNewMonitoring Behaviour Online: Tracking, Cookies and ConsentNewAnalysing Personal Information: Profiling and InferenceNewPiracy: Impacts on Creators, Users and IndustryNewOffensive Communications: Harm, Responsibility and EnforcementNewAccessibility: Layout, Colour Choices and Inclusive DesignNewComputers in the Workforce: Job Change, Deskilling and UpskillingNewEnvironmental Effects: Energy Use, E-Waste and SustainabilityNew
What Computational Thinking Is (and Isn’t)NewAbstraction: Removing Detail to Focus on the EssentialsNewChoosing What to Abstract: Fitness for PurposeNewModels and Simulations: When Abstractions Become ToolsNewThinking Ahead: Anticipating Inputs, Outputs and Edge CasesNewPreconditions and Postconditions in a SolutionNewThinking Procedurally: Defining Clear StepsNewDecomposition: Splitting Problems into Sub-ProblemsNewIdentifying Sub-Procedures and Reuse OpportunitiesNewThinking Logically: Building Conditions That Are CorrectNewBoolean Conditions: AND/OR/NOT in Problem SolvingNewTraceability: Following Logic Through a ProgramNewThinking Concurrently: Doing More Than One Thing at OnceNewConcurrency vs Parallelism: The Key DifferenceNewRace Conditions and Why Order MattersNew
From Problem Statement to RequirementsNewInput–Process–Output as a Starting FrameworkNewSelecting Data Types for a ProblemNewArithmetic, Logical and Boolean Operators in CodeNewSequence, Selection and Iteration in Real ProgramsNewNested Selection and Nested LoopsNewWriting Modular Code with Functions and ProceduresNewDesigning Clear Function InterfacesNewParameter Passing: By Value vs By ReferenceNewScope: Global vs Local VariablesNewRecursion: Base Case, Recursive Case and Stack BehaviourNewWhen Recursion Beats Iteration (and When It Doesn’t)NewDefensive Programming: Validation and Error HandlingNewUsing an IDE: Breakpoints, Watches and Step-Through DebuggingNewDebugging Strategies: Tracing, Logging and Unit TestsNewOOP in Practice: Defining and Using ClassesNewObjects, Methods and Attributes in CodeNewEncapsulation: Protecting State with Access ControlNewInheritance: Reuse and SpecialisationNewPolymorphism: Interfaces and OverridingNewProblem Recognition: Identifying the Real TaskNewProblem Decomposition: Structuring a Large SolutionNewDivide and Conquer: Splitting Work RecursivelyNewBacktracking: Searching with UndoNewHeuristics: “Good Enough” Strategies for Hard ProblemsNewData Mining Concepts: Patterns, Trends and UsesNewPerformance Modelling: Estimating Time/Space NeedsNewVisualisation: Using Diagrams to Understand a SystemNew
What Makes an Algorithm “Suitable” for a TaskNewCorrectness: Proving or Testing an Algorithm WorksNewMeasuring Complexity: Time vs SpaceNewBig O Notation: What It Describes (and What It Doesn’t)NewBest, Average and Worst Case ComplexityNewLinear Search: Step-by-Step TraceNewBinary Search: Preconditions and TraceNewBubble Sort: How It Works and Why It’s SlowNewInsertion Sort: When It’s a Good ChoiceNewMerge Sort: Divide, Merge and ComplexityNewQuick Sort: Partitioning and Performance Trade-OffsNewChoosing a Sort for a ScenarioNewDijkstra’s Algorithm: Shortest Path with Non-Negative WeightsNewTracing Dijkstra’s Algorithm on a GraphNewA* Algorithm: Heuristics and Informed SearchNewComparing Dijkstra vs A*NewStack Algorithms: Valid Push/Pop SequencesNewQueue Algorithms: Simulating Enqueue/DequeueNewLinked List Algorithms: Traversal, Insert and DeleteNewTree Algorithms: Traversal and SearchingNewBST Algorithms: Insert, Search and Delete TracesNew
Picking a Problem That Is Suitable for OCR NEANewStakeholders, Users and Clear Problem DefinitionNewInvestigating Existing Solutions and Setting Success CriteriaNewRequirements: Functional vs Non-FunctionalNewAnalysing Inputs, Outputs, Data and ConstraintsNewDesigning a Solution: Top-Down Design and DecompositionNewDesigning Data Structures for Your SolutionNewDesigning Algorithms for Key FeaturesNewUI/UX Design (Where Relevant): Layout and AccessibilityNewPlanning Development: Milestones and IterationsNewVersion Control Basics for NEA EvidenceNewBuilding a Test Strategy: Unit, Integration and System TestsNewWriting a Test Plan with Expected OutcomesNewDebugging Evidence: Showing How Issues Were Found and FixedNewEvaluating Against Success CriteriaNewLimitations, Improvements and Future WorkNewDocumentation That Gets Credit: What to Include and How to Present ItNewConsidering Legal, Ethical and Security Implications in Your ProjectNew
