Your journey to excellence inComputer Science

Algorithm vs Program (Same Idea, Different Thing)

Decomposition: Breaking a Problem into Sub-Problems

Abstraction: Removing Unnecessary Detail

A Systematic Approach to Solving Problems

Writing Algorithms in Pseudocode

Representing Algorithms with Flowcharts

Representing Algorithms with Program Code

Inputs, Processes and Outputs in an Algorithm

Spotting Inputs, Processes and Outputs in Given Pseudocode

Tracing an Algorithm with a Trace Table

Determining What a Simple Algorithm Does (Purpose)

Why Different Algorithms Can Solve the Same Problem

Comparing Algorithms by Time Efficiency (Faster vs Slower)

Linear Search: How It Works (Mechanics)

Linear Search: Tracing Step-by-Step

Binary Search: Why the Data Must Be Sorted

Binary Search: How It Works (Mechanics)

Binary Search: Tracing Step-by-Step

Linear vs Binary Search: Advantages and Disadvantages

Merge Sort: Splitting a List into Halves

Merge Sort: Merging Two Sorted Lists

Merge Sort: Tracing a Full Example

Bubble Sort: Swapping Adjacent Items

Bubble Sort: Passes, Comparisons and Swaps

Bubble Sort: Tracing a Full Example

Merge Sort vs Bubble Sort: Advantages and Disadvantages

Character and String Data Types

Choosing the Right Data Type for a Variable

Variables and Assignment (Storing and Updating Values)

Constants and Why They’re Useful

Meaningful Identifier Names (Readable Code)

Sequence: Running Statements in Order

Selection: IF, ELSEIF, ELSE Decisions

Nested Selection (IF Inside IF)

Count-Controlled Iteration (FOR Loops)

Condition-Controlled Iteration (WHILE / REPEAT UNTIL)

Avoiding Infinite Loops (Correct Conditions)

Arithmetic Operators: +, -, *, /, DIV, MOD

Order of Operations in Expressions

Relational Operators: =, ≠, <, >, ≤, ≥

Building Conditions with Relational Operators

Boolean Operators: AND, OR, NOT

Combining Boolean Conditions (With Brackets)

One-Dimensional Arrays: Indexes and Bounds

Iterating Through a 1D Array

Two-Dimensional Arrays: Rows, Columns and Indexes

Iterating Through a 2D Array (Nested Loops)

Records: Fields Inside a Single Data Item

Arrays of Records (Lists of Structured Items)

Input from a User (Keyboard / Form Input)

Output to a User (Screen / Console Output)

String Length and String Indexing

Substrings and String Slicing

Concatenating Strings

Converting Between Characters and Character Codes

Random Number Generation (Range and Use Cases)

Using Randomness in Algorithms (Games / Sampling)

Subroutines: Why We Use Them (Decomposition in Code)

Procedures vs Functions (Return Values)

Passing Parameters into a Subroutine

Using Return Values from Functions

Local vs Global Variables (Scope Basics)

Data Validation: Presence, Length and Range Checks

Data Validation: Format Checks (e.g. Type/Pattern)

Authentication: Usernames, Passwords and Access

CAPTCHA: Why It’s Used and What It Stops

Common Programming Errors: Syntax vs Logic

Testing Strategies: Normal, Boundary and Erroneous Test Data

Debugging: Finding and Fixing Errors from Test Results

Why Computers Use Binary

Bit Patterns: Same Bits, Different Meanings (Text/Image/Sound/Number)

Why Hexadecimal Is Useful in Computing

Binary Place Value (8-bit Numbers 0–255)

Writing Decimal Numbers (0–255) in Binary

Hex Place Value and Hex Digits (0–F)

Writing Decimal Numbers (0–255) in Hex

Converting Binary to Decimal

Converting Decimal to Binary

Converting Binary to Hex (Nibble Grouping)

Converting Hex to Binary (Nibble Expansion)

Converting Decimal to Hex

Converting Hex to Decimal

Bits and Bytes (b vs B)

Decimal Prefixes: kB, MB, GB, TB (Powers of 10)

Comparing File Sizes Using Prefixes

Adding Two Binary Numbers (With Carry)

Adding Three Binary Numbers (Column Rules)

Logical Shifts Left and Right (8-bit)

Using Shifts for Multiply/Divide by Powers of 2

What a Character Set Is

7-bit ASCII: Using an Encoding Table

Unicode: Why It Exists and Its Advantages over ASCII

Converting Characters to Codes (Using a Given Table)

Converting Codes to Characters (Using a Given Table)

Pixels and How a Bitmap Image Is Stored

Image Resolution and Colour Depth

Calculating Image File Size (Resolution × Colour Depth)

How Changing Resolution Affects Image Quality and File Size

How Changing Colour Depth Affects Image Quality and File Size

Sampling Sound: From Analogue to Digital

Sampling Rate and Sample Resolution (Bit Depth)

How Sampling Choices Affect Sound Quality

Calculating Sound File Size (Rate × Resolution × Time)

Why Data Compression Is Used

Lossy vs Lossless Compression (What Changes, What Doesn’t)

Run-Length Encoding: Creating Compressed Data

Run-Length Encoding: Decompressing Back to Original

Huffman Coding: Frequency Tables and Idea

Huffman Coding: Building/Using a Huffman Tree

Huffman Coding: Calculating Bits Saved

How Hardware and Software Work Together

Boolean Values: True/False as 1/0

The NOT Gate: Truth Table and Meaning

The AND Gate: Truth Table and Meaning

The OR Gate: Truth Table and Meaning

The XOR Gate: Truth Table and Meaning

Logic Gates with Three Inputs (Truth Tables)

Drawing Logic Circuits Using Gate Symbols

Reading a Logic Circuit to Produce a Truth Table

Combining Logic Gates into Larger Circuits

Boolean Expressions from Logic Circuits

Logic Circuits from Boolean Expressions

System Software vs Application Software

The Purpose of an Operating System

OS Management: Memory, Processor, Devices and Users

Utility Software: What It Is and Examples

Low-Level vs High-Level Programming Languages

Machine Code: What It Is and Why It’s Processor-Specific

Assembly Language: What It Is and Why It’s Used

Translators: Compiler, Interpreter and Assembler

Compiler vs Interpreter (Key Differences)

What Main Memory Does in a Computer System

CPU Components: ALU, Control Unit and Clock

Registers and Their Role (No Specific Registers Needed)

Buses: What They Are and Why They Matter

The Fetch-Decode-Execute Cycle (Full Cycle)

What Affects CPU Performance: Clock Speed

What Affects CPU Performance: Cores and Cache

RAM vs ROM (Volatile vs Non-Volatile)

Cache and Registers: Why They Exist

Main Memory vs Secondary Storage

Why Secondary Storage Is Needed

Magnetic Storage: How It Stores Data

Solid State Storage: How It Stores Data (High Level)

Magnetic vs Solid State: Pros and Cons

Cloud Storage: What It Means

Cloud Storage vs Local Storage: Pros and Cons

Embedded Systems: What They Are

Embedded vs Non-Embedded Systems (Examples)

Advantages of Using Networks

Disadvantages and Risks of Networks

PAN: What It Is (Bluetooth Only)

LAN: What It Is (Size and Ownership)

WAN: What It Is (The Internet as a WAN)

Wired vs Wireless Networks (Key Differences)

Wireless vs Wired: Advantages and Disadvantages

Copper vs Fibre Cabling (When Each Is Appropriate)

What a Network Protocol Is

IP: Addressing and Routing (Purpose)

TCP: Reliable Transmission (Purpose)

HTTP: How Web Pages Are Transferred (Purpose)

HTTPS: What Changes Compared to HTTP (Purpose)

SMTP: Sending Email (Purpose)

IMAP: Retrieving Email (Purpose)

Why Network Security Matters

Authentication on Networks (Users and Permissions)

Encryption on Networks (Protecting Data in Transit)

Firewalls: What They Do and How Rules Work

MAC Address Filtering: Allowing/Blocking Devices

Layering Security Methods Together (Defence in Depth)

The TCP/IP 4-Layer Model: Names of the Layers

Application Layer: What Happens Here

Transport Layer: What Happens Here

Internet Layer: What Happens Here

Link Layer: What Happens Here

Which Protocols Sit in Which TCP/IP Layer

The Main Purposes of Cyber Security

Social Engineering: What It Is

Blagging (Pretexting): How It Works

Phishing: How It Works (Email/SMS)

Shouldering (Shoulder Surfing): How It Works

Protecting Against Social Engineering (Practical Behaviours)

Malware: What It Is (Umbrella Term)

Computer Viruses: How They Spread and Harm

Trojans: Disguised Malware and Its Risks

Spyware: Monitoring Users and Stealing Data

Protecting Against Malware (Practical Steps)

Pharming: Redirecting Traffic to Fake Websites

Weak/Default Passwords: Why They’re Dangerous

Misconfigured Access Rights: How They Create Risks

Removable Media Threats (e.g. Infected USBs)

Unpatched/Outdated Software: Why It’s a Threat

Penetration Testing: What It Is Used For

Pen Testing: Internal Attack Simulation

Pen Testing: External Attack Simulation

Biometrics for Security (Especially Mobile Devices)

Password Systems (Strong Password Practice)

CAPTCHA and Automated Attack Prevention

Email Confirmations for Identity Checking

Automatic Software Updates as Protection

What a Relational Database Is

Tables, Records and Fields (Core Vocabulary)

Data Types in Databases (Why They Matter)

Primary Keys: Unique Identifiers

Foreign Keys: Linking Tables Together

Reducing Redundancy and Inconsistency with Relational Design

SELECT: Choosing Which Fields to Show

FROM: Choosing Which Table(s) to Use

WHERE: Filtering Records by a Condition

ORDER BY: Sorting Results ASC and DESC

Writing Queries Using Two Tables (Maximum)

INSERT INTO: Adding a New Record

UPDATE: Editing Existing Data Safely with WHERE

DELETE: Deleting Records Safely with WHERE

What “Legal Impact” Means in Digital Technology

What “Environmental Impact” Means in Digital Technology

Privacy: What People Expect and Why It Matters

Security vs Privacy: The Core Trade-Off (Safety vs Access)

Evaluating a Scenario: Stakeholders, Benefits and Risks

Cyber Security Impacts: Protection, Surveillance and Harm

Mobile Technologies: Location Tracking and Personal Data

Wireless Networking: Convenience vs Eavesdropping Risks

Cloud Storage: Data Ownership, Access and Jurisdiction Issues

Cloud Storage: Reliability, Outages and Dependency Risks

Hacking (Unauthorised Access): Harm, Motivations and Consequences

Wearable Tech: Health Data, Consent and Data Sharing

Computer-Based Implants: Safety, Consent and Data Security

Autonomous Vehicles: Safety, Liability and Decision-Making Ethics

Environmental Costs: Energy Use of Devices and Data Centres

Environmental Costs: E-waste and Product Lifecycles

Key UK Digital Laws (Overview: Data, Access, Copyright, Info Rights)

Writing a Program in a Text-Based High-Level Language

Testing a Program Systematically

Refining a Program Based on Test Evidence

Using Programming Tasks to Build Exam-Ready Skills

What the Practical Programming Statement Confirms (Opportunity to Practise)

Avoiding Malpractice in Practical Programming Evidence