Computer Science

The Fetch-Decode-Execute Cycle

CPU Components and Their Functions

RISC vs. CISC Architecture

Factors Affecting CPU Performance

Input, Output, and Storage Devices

Primary vs. Secondary Storage: A Comparison

Offline Storage Devices

Cache Memory and Its Importance

The Role of Registers in the CPU

Buses and Their Role in Computer Architecture

Knowledge Check: Summary & Quizzes

Operating Systems (OS) and Their Functions

Utility Programs and System Maintenance

General-Purpose vs. Bespoke Software

Waterfall Model: A Step-by-Step Guide

Agile Development Methodology Explained

Extreme Programming (XP) Principles

High-Level and Low-Level Languages

Language Translators

Integrated Development Environments (IDEs)

Knowledge Check: Summary & Quizzes

Compression, Encryption, and Hashing

Relational Databases and SQL

Network Topologies and Protocols

The Internet: DNS, IP Addressing, and Cloud Computing

Knowledge Check: Exercises and Questions

Data Types

Data Structures

Algorithms

Knowledge Check: Exercises and Questions

Legal Considerations

Moral & Ethical Considerations

Cultural Considerations

Environmental Considerations

Answering Exam Questions on this topic

Abstractional Thinking

Procedural Thinking

Logical Thinking

Thinking Ahead

Adaptive Thinking

Answering Exam Questions on this topic

Problem-Solving Techniques

Programming Techniques

Writing & Following Algorithms

Use of Programming Languages

Knowledge Check: Exercises and Questions

Algorithm Design

Big-O Notation

Standard Algorithms

Algorithm Design Techniques

Linear Data Structures

What the CPU Does: The Stored Program Concept

CPU Components: ALU, Control Unit, Registers and Buses

Key Registers: PC, MAR, MDR, ACC and Status Register

The Fetch–Decode–Execute Cycle Step-by-Step

How Instructions and Data Move Around the Von Neumann Model

Von Neumann vs Harvard Architecture

Interrupts: Why They Exist and What They Enable

Interrupt Handling: ISR, Interrupt Vector and Context Switching

Polling vs Interrupts

CPU Performance Factors: Clock Speed, Cores, Cache and Instruction Set

The Role of Cache and Why It Improves Performance

Pipelining: How It Works and Why It Helps

Pipeline Hazards and How They Reduce Speed-Up

RISC vs CISC: Trade-Offs and Use Cases

GPUs: Why They’re Different from CPUs

Multicore vs Parallel Processing: Key Ideas and Examples

Input Devices: Sensors, Human Input and Embedded Inputs

Output Devices: Displays, Actuators and Control Outputs

Storage Types: Magnetic, Optical and Solid-State

RAM vs ROM: Purpose, Characteristics and Use

Virtual Memory: Why It Exists and the Performance Cost

What Systems Software Is and Why It Matters

Operating System Core Functions: UI, File, Device and Resource Management

Process Management: Processes, Threads and Multitasking

Memory Management: Allocation, Protection and Virtual Memory

Paging and the Idea of a Page Table

System Interrupts: Sources and OS Response

Scheduling Goals: Throughput, Responsiveness and Fairness

Scheduling Algorithms: FCFS, SJF and Round Robin

Types of Operating System: Batch, Multi-User, Real-Time and Embedded

BIOS and the Boot Process

Device Drivers: Purpose and How They Enable Hardware Abstraction

Virtual Machines: How They Work and Why They’re Used

Application Software vs Utility Software

Open Source vs Closed Source: Licensing and Development Implications

Translators: Assembler vs Compiler vs Interpreter

Stages of Compilation: Lexing, Parsing, Code Generation and Optimisation

Libraries: Why We Use Them and How They Speed Development

Linkers and Loaders: From Object Code to Running Program

Waterfall Model: Phases, Strengths and Weaknesses

Agile Development: Iteration, User Stories and Continuous Feedback

Spiral Model: Risk-Driven Iteration

Rapid Application Development: Prototyping and User Involvement

Choosing a Development Methodology for a Scenario

Programming Paradigms: Procedural, OOP and Declarative Overview

Assembly Language: Why Low-Level Still Matters

Little Man Computer: Modelling Machine-Level Execution

Addressing Modes: Immediate, Direct, Indirect and Indexed

Lossless vs Lossy Compression: When Each Is Appropriate

Run Length Encoding: Encoding and Decoding Worked Examples

Dictionary Coding: Building a Dictionary and Representing Data

Why Compression Works: Redundancy and Patterns

Symmetric Encryption: Keys, Speed and Typical Uses

Asymmetric Encryption: Public/Private Keys and Typical Uses

Key Exchange and Real-World Secure Communication

Hashing: What a Hash Is and What It’s For

Hashing Uses: Integrity Checking, Password Storage and Verification

Relational Databases: Tables, Rows, Columns and Keys

Primary Keys, Foreign Keys and Relationships

Entity Relationship Diagrams: Entities, Attributes and Cardinality

Designing a Database Schema from a Scenario

Normalisation: Why We Do It (Redundancy and Anomalies)

First Normal Form: Removing Repeating Groups

Second Normal Form: Removing Partial Dependencies

Third Normal Form: Removing Transitive Dependencies

SQL Basics: SELECT, WHERE, ORDER BY and Aggregates

SQL Joins: Why They’re Needed and How They Work

Data Validation vs Verification in Data Capture

Capturing and Selecting Data: Sampling, Bias and Data Quality

Transaction Processing: What It Is and Why It Matters

ACID Properties: What Each One Protects Against

Networks: LAN vs WAN and Typical Features

Client–Server vs Peer-to-Peer: Strengths and Weaknesses

TCP/IP Model: Layers and What Happens at Each

IP Addressing and Routing: Core Ideas

DNS: Why It Exists and How a Lookup Works

Packet vs Circuit Switching: Comparing How Data Moves

Network Hardware: Switches, Routers, WAPs and NICs

Network Threats: Malware, Phishing, Man-in-the-Middle and DoS

Network Security Controls: Firewalls, Encryption and Authentication

Search Engine Indexing: Crawling, Indexing and Retrieval

Page Ranking: Why Ordering Results Is Hard

Server-Side vs Client-Side Processing

HTML Structure: Elements, Attributes and Semantic Layout

CSS: Selectors and Styling Rules

JavaScript Basics: Variables, Selection and Iteration

JavaScript Functions: Parameters and Return Values

Primitive Data Types: Integer, Real, Boolean and Character

Binary Place Value and Converting to Decimal

Representing Positive Integers in Binary

Two’s Complement: Representing Negative Integers

Range, Overflow and What Happens When It Breaks

Binary Addition Worked Examples

Binary Subtraction Worked Examples

Hexadecimal: Converting and Why It’s Useful

Floating Point Representation: Mantissa and Exponent

Floating Point Precision and Rounding Error

Floating Point Arithmetic: Common Pitfalls

Bitwise Operations: AND, OR, XOR and NOT

Bit Shifts and Their Uses

Masks: Setting, Clearing and Testing Bits

Character Sets: ASCII vs Unicode

Arrays: Indexing, Traversal and Common Operations

Records, Lists and Tuples: When Each Fits Best

Linked Lists: Nodes, Pointers and Traversal

Linked List Operations: Insert and Delete

Stacks: LIFO and Push/Pop Operations

Queues: FIFO and Enqueue/Dequeue Operations

Graphs: Vertices, Edges and Representations

Adjacency Matrix vs Adjacency List

Graph Traversal: Visiting and Tracking State

Trees: Root, Parent/Child, Leaf and Height

Tree Traversal: Preorder, Inorder and Postorder

Binary Search Trees: Ordering Rules and Search

BST Operations: Insert and Delete

Hash Tables: Hash Functions and Collisions

Collision Handling: Chaining vs Open Addressing

Boolean Logic: Operators and Truth Tables

Laws of Boolean Algebra and Simplification

De Morgan’s Laws in Logic Expressions

Karnaugh Maps: Simplifying Boolean Expressions

Flip-Flops: SR, D and JK as Memory Elements

Registers and Counters from Flip-Flops

Half Adder vs Full Adder

Ripple Carry Adders: How Multi-Bit Addition Works

Why Computing Raises Legal and Ethical Challenges

The Data Protection Act 1998: Key Principles and Responsibilities

Data Controllers and Data Subjects: Roles and Duties

The Computer Misuse Act 1990: Core Offences and Examples

The Copyright, Designs and Patents Act 1988: Protecting Software and Media

Licensing: What You Can and Can’t Do with Software

The Regulation of Investigatory Powers Act 2000: Monitoring and Interception

Artificial Intelligence: Benefits, Risks and Accountability

Bias in Automated Systems: Where It Comes From

Automated Decision-Making: Transparency and Appeal

Censorship and The Internet: Competing Interests

Monitoring Behaviour Online: Tracking, Cookies and Consent

Analysing Personal Information: Profiling and Inference

Piracy: Impacts on Creators, Users and Industry

Offensive Communications: Harm, Responsibility and Enforcement

Accessibility: Layout, Colour Choices and Inclusive Design

Computers in the Workforce: Job Change, Deskilling and Upskilling

Environmental Effects: Energy Use, E-Waste and Sustainability

What Computational Thinking Is (and Isn’t)

Abstraction: Removing Detail to Focus on the Essentials

Choosing What to Abstract: Fitness for Purpose

Models and Simulations: When Abstractions Become Tools

Thinking Ahead: Anticipating Inputs, Outputs and Edge Cases

Preconditions and Postconditions in a Solution

Thinking Procedurally: Defining Clear Steps

Decomposition: Splitting Problems into Sub-Problems

Identifying Sub-Procedures and Reuse Opportunities

Thinking Logically: Building Conditions That Are Correct

Boolean Conditions: AND/OR/NOT in Problem Solving

Traceability: Following Logic Through a Program

Thinking Concurrently: Doing More Than One Thing at Once

Concurrency vs Parallelism: The Key Difference

Race Conditions and Why Order Matters

From Problem Statement to Requirements

Input–Process–Output as a Starting Framework

Selecting Data Types for a Problem

Arithmetic, Logical and Boolean Operators in Code

Sequence, Selection and Iteration in Real Programs

Nested Selection and Nested Loops

Writing Modular Code with Functions and Procedures

Designing Clear Function Interfaces

Parameter Passing: By Value vs By Reference

Scope: Global vs Local Variables

Recursion: Base Case, Recursive Case and Stack Behaviour

When Recursion Beats Iteration (and When It Doesn’t)

Defensive Programming: Validation and Error Handling

Using an IDE: Breakpoints, Watches and Step-Through Debugging

Debugging Strategies: Tracing, Logging and Unit Tests

OOP in Practice: Defining and Using Classes

Objects, Methods and Attributes in Code

Encapsulation: Protecting State with Access Control

Inheritance: Reuse and Specialisation

Polymorphism: Interfaces and Overriding

Problem Recognition: Identifying the Real Task

Problem Decomposition: Structuring a Large Solution

Divide and Conquer: Splitting Work Recursively

Backtracking: Searching with Undo

Heuristics: “Good Enough” Strategies for Hard Problems

Data Mining Concepts: Patterns, Trends and Uses

Performance Modelling: Estimating Time/Space Needs

Visualisation: Using Diagrams to Understand a System

What Makes an Algorithm “Suitable” for a Task

Correctness: Proving or Testing an Algorithm Works

Measuring Complexity: Time vs Space

Big O Notation: What It Describes (and What It Doesn’t)

Best, Average and Worst Case Complexity

Linear Search: Step-by-Step Trace

Binary Search: Preconditions and Trace

Bubble Sort: How It Works and Why It’s Slow

Insertion Sort: When It’s a Good Choice

Merge Sort: Divide, Merge and Complexity

Quick Sort: Partitioning and Performance Trade-Offs

Choosing a Sort for a Scenario

Dijkstra’s Algorithm: Shortest Path with Non-Negative Weights

Tracing Dijkstra’s Algorithm on a Graph

A* Algorithm: Heuristics and Informed Search

Comparing Dijkstra vs A*

Stack Algorithms: Valid Push/Pop Sequences

Queue Algorithms: Simulating Enqueue/Dequeue

Linked List Algorithms: Traversal, Insert and Delete

Tree Algorithms: Traversal and Searching

BST Algorithms: Insert, Search and Delete Traces

Picking a Problem That Is Suitable for OCR NEA

Stakeholders, Users and Clear Problem Definition

Investigating Existing Solutions and Setting Success Criteria

Requirements: Functional vs Non-Functional

Analysing Inputs, Outputs, Data and Constraints

Designing a Solution: Top-Down Design and Decomposition

Designing Data Structures for Your Solution

Designing Algorithms for Key Features

UI/UX Design (Where Relevant): Layout and Accessibility

Planning Development: Milestones and Iterations

Version Control Basics for NEA Evidence

Building a Test Strategy: Unit, Integration and System Tests

Writing a Test Plan with Expected Outcomes

Debugging Evidence: Showing How Issues Were Found and Fixed

Evaluating Against Success Criteria

Limitations, Improvements and Future Work

Documentation That Gets Credit: What to Include and How to Present It

Considering Legal, Ethical and Security Implications in Your Project