Your journey to excellence in
By Revision Genie
Fundamentals of programming
Unit 1
What a Data Type Is
Integers, Reals/Floats and When to Use Each
Booleans and Boolean Variables
Characters vs Strings
Date/Time Values in Programs
Pointers and References: What They Store
Records as User-Defined Structured Types
Arrays as Collections of Same-Type Items
Creating Your Own Data Types from Built-Ins
Variable Declarations and Assignments
Constants and Why Named Constants Matter
Sequence, Selection and Iteration in Real Code
Definite Iteration: Counting Loops
Indefinite Iteration: Condition-Controlled Loops
Conditions at the Start vs End of a Loop
Nested Selection (If Inside If)
Nested Iteration (Loops Inside Loops)
Meaningful Identifier Names and Why They Matter
Arithmetic Operators Including Integer Division and Remainders
Rounding vs Truncation in Computations
Relational Operators and Building Conditions
Boolean Operators: NOT, AND, OR, XOR
String Length and Character Positions
Substrings and Slicing
Concatenation and Building Strings
Character Code Conversions (Char ↔ Code)
Converting Between String and Integer
Converting Between String and Float
Converting Date/Time to and from Strings
Random Number Generation and Typical Uses
What Exception Handling Is For
Using Try/Catch (or Equivalent) in Your Language
What a Subroutine Is (Procedure vs Function)
Why Subroutines Improve Programs (Reuse, Readability, Testing)
Parameters: Passing Data Into Subroutines
Designing Clear Subroutine Interfaces
Returning Values from Functions
Local Variables and Why They’re Good Practice
Global Variables and Their Risks
Stack Frames: Return Addresses, Parameters and Locals
Recursion: Base Case and General Case
Solving Simple Problems Using Recursion
Procedural Programming: Key Characteristics
Object-Oriented Programming: Key Characteristics
When to Choose Procedural vs OOP
Classes and Objects: Definitions and Differences
Instantiation and Constructors
Encapsulation and Data Hiding in OOP
Inheritance and “Is-a” Relationships
Aggregation vs Composition
Polymorphism and Overriding
Public, Private and Protected Access
Abstract, Virtual and Static Methods
Drawing Class Diagrams (UML Basics)
Reading Class Diagrams (UML Notation)
OOP Design Principles: Encapsulate What Varies
OOP Design Principles: Favour Composition
OOP Design Principles: Program to Interfaces
Unit 2
Fundamentals of data structures
What a Data Structure Is
Single-Dimensional Arrays in Solutions
Two-Dimensional Arrays as Matrices
Choosing 1D vs 2D vs nD Arrays
Fields and Records in Data Storage
Text Files: Reading and Writing
Binary Files: Reading and Writing
Abstract Data Types vs Concrete Implementations
Static vs Dynamic Data Structures
When Static Structures Are Better
When Dynamic Structures Are Better
What a Queue Is and Where It’s Used
Linear Queue: Adding an Item
Linear Queue: Removing an Item
Linear Queue: Testing Empty and Full
Circular Queue: Why It Exists
Circular Queue: Add, Remove, Empty, Full
Priority Queue: What Priority Means
Priority Queue: Add and Remove Rules
What a Stack Is and Where It’s Used
Stack Operations: Push
Stack Operations: Pop
Stack Operations: Peek/Top
Stack Tests: Empty and Full
Graphs: Nodes, Edges and Real Uses
Weighted Graphs and Why Weights Matter
Directed vs Undirected Graphs
Representing Graphs with an Adjacency Matrix
Representing Graphs with an Adjacency List
Comparing Adjacency Matrices vs Lists
Trees as Graphs with No Cycles
Rooted Trees and Parent–Child Relationships
Binary Trees and “At Most Two Children”
Binary Search Trees and Sorted Searching
Hash Tables: Keys, Values and Lookups
Simple Hash Functions (Applying a Hash)
Collisions and Why They Happen
Handling Collisions with Rehashing
Dictionaries as Key–Value Collections
Using Dictionaries for Information Retrieval
Vectors as Lists of Numbers
Vectors as Functions (Index ↦ Value)
Vector Addition as Translation
Scalar-Vector Multiplication as Scaling
Convex Combinations of Two Vectors
Dot Product: Calculating and Interpreting
Dot Product Applications (Angle Between Vectors)
Unit 3
Fundamentals of algorithms
Breadth-First Search: Tracing Step-by-Step
Depth-First Search: Tracing Step-by-Step
BFS vs DFS: When Each Is Used
Pre-Order Tree Traversal: Tracing
In-Order Tree Traversal: Tracing
Post-Order Tree Traversal: Tracing
Matching Traversals to Real Uses
What Reverse Polish Notation (RPN) Is
Converting Infix to RPN Using a Stack
Converting RPN Back to Infix
Why RPN Removes the Need for Brackets
Linear Search: How It Works
Linear Search Time Complexity
Binary Search: Preconditions (Sorted Data)
Binary Search: Tracing Midpoints
Binary Search Time Complexity
Binary Tree Search: Tracing in a BST
BST Search Time Complexity (Balanced Case)
Bubble Sort: Passes and Swaps
Bubble Sort Time Complexity
Merge Sort: Divide and Conquer Idea
Merge Sort: Merging Two Sorted Lists
Merge Sort Time Complexity
Dijkstra’s Algorithm: Tracing Shortest Paths
Where Shortest Path Algorithms Are Used
Unit 4
Theory of computation
Solving Simple Logic Problems Systematically
Checking Logic Solutions for Correctness
What an Algorithm Is and Why It Must Terminate
Writing Algorithms in Pseudocode
Using Sequence, Assignment, Selection and Iteration in Pseudocode
Hand-Tracing an Algorithm with Test Data
Converting Pseudocode to Program Code
Explaining How a Program Works (Correctness Argument)
Representational Abstraction: Removing Unnecessary Detail
Generalisation and Categorisation Abstraction
Information Hiding: Keeping Only Essential Characteristics
Procedural Abstraction: Turning a Pattern into a Procedure
Functional Abstraction: Hiding the Computation Method
Data Abstraction: Separating Use from Representation
Problem Reduction: Turning a Problem into a Solved Form
Decomposition: Splitting into Sub-Problems
Composition: Combining Procedures into Larger Procedures
Automation: From Model to Running System
FSMs Without Output: State Diagrams and Tables
FSMs With Output: Mealy Machines
Sets: Roster Notation and Set Comprehension
Empty Set and Basic Set Vocabulary
Finite, Infinite and Countably Infinite Sets
Cardinality and What It Measures
Cartesian Product and Ordered Pairs
Subset vs Proper Subset
Set Operations: Membership, Union, Intersection, Difference
What a Regular Expression Represents
Regex Metacharacters: *, +, ?, | and Grouping
Writing Simple Regular Expressions for Matching
Regular Expressions and FSMs: How They Relate
Converting an FSM to a Simple Regular Expression
Converting a Simple Regular Expression to an FSM
What a Regular Language Is
Reading Syntax from BNF
Using Syntax Diagrams to Check Valid Strings
Writing Simple Production Rules
Why BNF Can Describe More Than Regular Expressions
Comparing Algorithms by Problem Size
Time Complexity vs Space Complexity
Functions Needed for Big-O (Linear, Polynomial, Exponential, Log)
Big-O Growth: Constant, Log, Linear, Polynomial, Exponential
Deriving Big-O from an Algorithm
Limits of Computation: Hardware and Complexity
Tractable vs Intractable Problems
Heuristics for Intractable Problems
Computable vs Non-Computable Problems
The Halting Problem: What It Says and Why It Matters
Turing Machine Components: States, Alphabet, Tape, Head
Start States and Halting States
Transition Functions vs State Transition Diagrams
Hand-Tracing a Simple Turing Machine
Why Turing Machines Matter for “Computable”
The Universal Turing Machine Idea
Unit 5
Fundamentals of data representation
Natural Numbers and the Set of Naturals
Integers and Negative Values
Rational Numbers as Fractions
Irrational Numbers and Why They Don’t Fractionise
Real Numbers as “Possible Real-World Quantities”
Ordinal Numbers for Position
Counting vs Measurement (Natural vs Real)
What a Number Base Is
Decimal, Binary and Hexadecimal Bases
Writing Base Notation with Subscripts
Converting Decimal to Binary
Converting Binary to Decimal
Converting Between Binary and Hexadecimal
Why Hex Is a Shorthand for Binary
Bits as the Fundamental Unit
Bytes as 8 Bits
How n Bits Represent 2^n Values
Binary Prefixes: Ki, Mi, Gi, Ti
Decimal Prefixes: k, M, G, T
Why KB vs KiB Gets Confused
Unsigned vs Signed Binary: The Difference
Unsigned Binary Ranges for n Bits
Converting Unsigned Binary ↔ Decimal
Adding Unsigned Binary Numbers
Multiplying Unsigned Binary Numbers
Two’s Complement: Representing Negative Integers
Two’s Complement: Converting Signed Binary ↔ Decimal
Two’s Complement Subtraction Method
Signed Range Calculations for n Bits
Fixed Point Binary for Fractions
Floating Point: Mantissa + Exponent (Simplified Model)
Converting Fixed Point Binary ↔ Decimal
Converting Floating Point Binary ↔ Decimal (Given Bits)
Rounding Errors in Fixed and Floating Point
Using Binary Fractions to Explain Inaccuracy
Absolute Error: Calculating It
Relative Error: Calculating It
Comparing Absolute vs Relative Error
Range, Precision and Speed: Fixed vs Floating Point
Normalising Floating Point Values
Underflow vs Overflow and When They Occur
Digit Character Code vs Numeric Value
ASCII: What It Is
Unicode: Why It Was Introduced
Parity Bits for Error Checking
Majority Voting for Error Correction
Checksums: What They Do
Check Digits: Detecting Errors (eg ISBN-style)
Bit Patterns Representing Images and Sound
Analogue vs Digital Data
Analogue vs Digital Signals
How an ADC Works in Principle
How a DAC Works in Principle
Bitmapped Images: Pixels, Resolution and Colour Depth
Calculating Bitmap Storage Requirements
Bitmap Metadata: Typical Examples
Vector Graphics: Objects and Properties
Creating a Simple Vector Graphic with Primitives
Vector vs Bitmap: Pros, Cons and Use Cases
Sound Sampling Rate and Sample Resolution
Nyquist Theorem and Why It Matters
Calculating Sound File Sizes
MIDI: Purpose and Event Messages
Why MIDI Can Be Better Than Audio Samples
Why Compression Is Used for Media
Lossless vs Lossy Compression
Run Length Encoding (RLE): The Core Idea
Dictionary-Based Compression: The Core Idea
What Encryption Means (Plaintext, Ciphertext, Cipher)
Caesar Cipher: Encrypting and Decrypting
Caesar Cipher: Why It’s Easy to Crack
Vernam Cipher (One-Time Pad): Encrypting and Decrypting
Vernam Cipher: Why It Has Perfect Security
Computational Security vs Perfect Security
Unit 6
Fundamentals of computer systems
Hardware vs Software: Clear Definitions
System Software vs Application Software
Why Different Software Types Exist
Operating Systems: Core Purpose
OS as a Hardware Complexity “Hider”
Resource Management: CPU, Memory and I/O
Utility Programs and Typical Examples
Libraries and Why Programmers Use Them
Translators: Why They’re Needed
Low-Level Languages: Machine Code Basics
Low-Level Languages: Assembly Basics
High-Level Imperative Languages: What They Are
Machine Code vs Assembly vs High-Level: Pros and Cons
Assembler: Role and Output
Compiler: Role and Output
Interpreter: Role and Output
Compilation vs Interpretation: When Each Is Better
Bytecode and Why Some Compilers Produce It
Source Code vs Object/Executable Code
Logic Gate Symbols and Conventions
NOT Gate: Truth Table and Use
AND Gate: Truth Table and Use
OR Gate: Truth Table and Use
XOR Gate: Truth Table and Use
NAND Gate: Truth Table and Use
NOR Gate: Truth Table and Use
Interpreting Multi-Gate Circuit Diagrams
Completing Truth Tables for Whole Circuits
Writing Boolean Expressions from Circuits
Drawing Circuits from Boolean Expressions
Boolean Identities for Simplifying Expressions
De Morgan’s Laws in Simplification
Half-Adder: What It Does
Half-Adder Circuit: Building and Tracing
Full-Adder: What It Does
Full-Adder Circuit: Recognising and Tracing
D-Type Flip-Flop as a Memory Unit
Unit 7
Fundamentals of computer organisation and architecture
Core Internal Components of a Computer System
Processor, Main Memory and I/O Controllers
The Address Bus: Purpose and Direction
The Data Bus: Purpose and Direction
The Control Bus: Purpose and Signals
Why Buses Are Needed for Communication
Von Neumann Architecture: Key Idea
Harvard Architecture: Key Idea
Where Von Neumann Is Typically Used
Where Harvard Is Typically Used
Addressable Memory: What It Means
The Stored Program Concept
ALU, Control Unit and Clock: Roles
General-Purpose Registers: Why They Exist
Program Counter (PC): Role
Current Instruction Register (CIR): Role
Memory Address Register (MAR): Role
Memory Buffer Register (MBR): Role
Status Register: Role
Fetch Stage: What Happens
Decode Stage: What Happens
Execute Stage: What Happens
Register Use Through the Fetch–Execute Cycle
Instruction Sets and Why They’re Processor-Specific
Opcodes and Operands in Instructions
Immediate Addressing: Meaning and Examples
Direct Addressing: Meaning and Examples
Assembly/Machine Operations: LOAD
Assembly/Machine Operations: ADD and SUBTRACT
Assembly/Machine Operations: STORE
Branching: Conditional vs Unconditional
COMPARE and Using Flags/Status
Bitwise Operators: AND, OR, NOT, XOR
Shifts: Left Shift vs Right Shift
HALT and Program Termination
Multiple Cores and Performance Effects
Cache Memory and Why It Speeds Up Execution
Clock Speed vs Real Performance
Word Length and What It Affects
Address Bus Width and Maximum Addressable Memory
Data Bus Width and Throughput
Input/Output Devices: Characteristics and Suitability
Barcode Readers: How They’re Used
Digital Cameras: Inputs and Data Considerations
Laser Printers: Output Characteristics
RFID: Purpose and Typical Use
Why Secondary Storage Is Needed
Hard Disks: How They Work and When They Fit
Optical Disks: Characteristics and Use Cases
SSDs: How They Work (High Level) and Why They’re Fast
Comparing Storage Media by Speed and Capacity
Unit 8
Consequences of uses of computing
What “Moral, Social, Ethical, Legal and Cultural” Means in CS
How Computing Enables Behaviour Monitoring
Personal Data Collection at Scale
Personal Data Analysis and Profiling
Publishing and Disseminating Personal Information
Power and Responsibility of Computer Scientists
How Algorithms Embed Values
Scale: How Software Can Do Great Good
Scale: How Software Can Cause Great Harm
The Challenge of Writing Effective Digital-Age Laws
Informed Consent in Digital Systems
Privacy Expectations Across Cultures
Case Studies: Identifying Stakeholders and Trade-Offs
Evaluating Risks, Safeguards and Unintended Consequences
Unit 9
Fundamentals of communication and networking
Serial vs Parallel Transmission
Why Serial Often Beats Parallel in Practice
Synchronous vs Asynchronous Transmission
Start Bits and Stop Bits: Purpose
Baud Rate vs Bit Rate
Bandwidth: Meaning in Data Transmission
Latency: Meaning and Impact
What a Protocol Is
Bit Rate and Bandwidth Relationship
Physical Star Topology: How It’s Wired
Logical Bus Topology: How It Behaves
Star vs Bus: Differentiating Physical and Logical
Peer-to-Peer Networking: When It Fits
Client–Server Networking: When It Fits
WiFi as a Wireless LAN Standard
Wireless Adapter vs Wireless Access Point
Securing WiFi: WPA/WPA2 and Other Measures
CSMA/CA: Collision Avoidance Idea
RTS/CTS: Why It Helps
SSID: What It Is and Why It Matters
Internet Structure: Networks of Networks
Packet Switching: Why It’s Used
Routers: Role in Forwarding Packets
Gateways: Role Between Networks
What’s Inside a Packet (Key Components)
How Routing Works Across the Internet
URLs: What They Identify
FQDN vs Domain Name vs IP Address
How Domain Names Are Organised
DNS: Purpose and How It Supports Domain Lookups
Internet Registries: What They Do and Why Needed
Firewalls: Packet Filtering
Firewalls: Proxy Servers
Firewalls: Stateful Inspection
Symmetric Encryption: What It Is
Asymmetric Encryption: Public/Private Keys
Key Exchange: The Core Problem and Idea
Digital Certificates: What They Prove
Digital Signatures: What They Prove
Worms vs Trojans vs Viruses
Vulnerabilities Malware Exploits
Reducing Malware Risk: Code Quality and Monitoring
TCP/IP Layers: Application, Transport, Network, Link
Sockets: How Applications Use the Stack
MAC Addresses and Local Network Delivery
Well-Known Ports vs Client Ports
FTP: What It’s For
Anonymous vs Non-Anonymous FTP Access
HTTP vs HTTPS: Core Differences
POP3 and Retrieving Email
SMTP and Sending Email
SSH: Secure Remote Management
SSH Clients and Remote Port Connections
Email Servers: Receiving, Storing, Sending
Web Servers: Serving Pages and Resources
Web Browsers: Fetching and Rendering
IP Address: Network Part vs Host Part
Subnet Masks: Identifying the Network Part
IPv4 vs IPv6: What Changed and Why
Public vs Private IP Addresses
DHCP: Automatic IP Configuration
NAT: Why It’s Used
Port Forwarding: Why It’s Used
Client–Server Messages: Request and Response
WebSockets: Persistent Full-Duplex Connections
CRUD: Create, Retrieve, Update, Delete
REST: Mapping CRUD to HTTP Methods
REST and Database Operations (GET/POST/PUT/DELETE)
JSON vs XML: Similarities and Differences
Thin Client vs Thick Client Computing
Unit 10
Fundamentals of databases
Turning Requirements into a Simple Data Model
Entities and Attributes: Identifying Them
Entity Identifiers and Underlining Keys
Drawing an ER Diagram from a Scenario
Writing Entity Descriptions (Entity(Attribute, Attribute…))
What a Relational Database Is
Attributes, Primary Keys and Composite Keys
Foreign Keys and Relationships Between Tables
Why Normalisation Is Needed
Normalising to Third Normal Form (3NF)
Properties of a 3NF Relation
SQL SELECT: Retrieving Data from One Table
SQL SELECT with Multiple Tables (Joins Conceptually)
SQL INSERT: Adding Data
SQL UPDATE: Changing Data
SQL DELETE: Removing Data
SQL DDL: Creating a Table
Client–Server Databases and Multiple Users
What “Concurrent Access” Means
Lost Update Problems and Why They Happen
Controlling Concurrency: Record Locks
Controlling Concurrency: Serialisation
Controlling Concurrency: Timestamp and Commitment Ordering
Unit 11
Big Data
What “Big Data” Means Beyond “Lots of Data”
Volume: Too Big for One Server
Velocity: Streaming Data and Fast Response Needs
Variety: Structured vs Unstructured vs Multimedia
Why Lack of Structure Is the Hardest Part
Why Relational Databases Struggle with Big Data
Machine Learning as Pattern-Finding in Big Data
When Processing Must Be Distributed
Why Functional Programming Helps Distributed Processing
Immutability: Why It Reduces Bugs
Statelessness: Why It Distributes Well
Higher-Order Functions: Why They Scale
Fact-Based Data Models: One Fact per Statement
Graph Schema: Capturing Dataset Structure
Nodes, Edges and Properties in Graph Data
Unit 12
Fundamentals of functional programming
Functional Programming as a Paradigm
Function Types: A → B
Domain vs Co-Domain
Outputs as a Subset of the Co-Domain
Functions as First-Class Objects
Function Application: Applying Inputs to a Function
Functions Taking One Argument as a Pair (Cartesian Product)
Partial Application: Creating a New Function from One Input
Currying View: A → B → C Style
Composition of Functions: g ∘ f
Building Simple Programs in a Functional Language
Higher-Order Functions: Taking or Returning Functions
map: Applying a Function Across a List
filter: Keeping Only Items That Match a Condition
reduce/fold: Combining a List into One Value
Lists as Head and Tail
Empty Lists and Base Cases
Returning the Head of a List
Returning the Tail of a List
Testing for an Empty List
Finding the Length of a List
Constructing an Empty List
Prepending an Item to a List
Appending an Item to a List
Unit 13
Systematic approach to problem solving
Defining a Problem Clearly Before Solving It
Gathering Requirements from Intended Users
Building a Data Model from the Real World
Using Abstraction to Model Reality
Designing Before Coding: Choosing Data Structures
Designing Before Coding: Choosing Algorithms
Designing Modular Program Structure
Designing a Human User Interface
Interfaces Between Modules: What to Document
Design as an Iterative Process
Prototyping and Agile as Requirement Clarification
Implementation: Turning Models into Data Structures
Implementation: Turning Algorithms into Code
Debugging as Part of Implementation
Explaining Correctness Using Reasoning and Test Data
Testing with Normal (Typical) Data
Testing with Boundary Data
Testing with Erroneous Data
Evaluating Against Success Criteria
Unit 14
Non-exam assessment: the computing practical project
What the NEA Is Assessessing Overall
Choosing a Problem You Understand (Or Can Research)
Choosing a Problem with Enough Technical Demand
Example Project Types (Simulation, Game, Control, Data, AI, etc)
Avoiding Overlap Between Students’ Projects
Using Iterative Development (Not Pure Waterfall)
Prototyping Early: Why It’s Recommended
Identifying and Tackling the Critical Path Early
Required Documentation Order and What Each Section Is
Analysis Section: What Evidence Looks Like
Documented Design Section: What Evidence Looks Like
Technical Solution Section: What “Programmed Solution” Means
Testing Section: Selecting Representative Samples
Evaluation Section: Judging Against Requirements
Understanding the Mark Distribution Across Sections
Picking Technical Skills at the Right Standard (Groups A/B/C)
Data Models at Higher Standard (eg Interlinked Tables, Complex Models)
Algorithms at Higher Standard (eg Traversals, Recursion, Efficient Sorts)
Client–Server / API Skills as Higher Standard Options
Coding Style: Basic Expectations
Coding Style: Good Expectations
Coding Style: Excellent Expectations
Using the Level of Response Mark Scheme (How Marking Works)
Let's master Computer Science together!Let's master Computer Science together!Let's master Computer Science together!