GCSE Computer Science Revision

Abstraction: removing unnecessary detail

Using decomposition + abstraction to model real-world problems

Why subprograms help (reuse, readability, testing)

What an algorithm is (inputs, processing, outputs)

Flowcharts: reading and writing standard symbols

Pseudocode: writing clear, language-agnostic steps

Program code as an algorithm representation

Sequence: writing steps in the correct order

Selection: making decisions with conditions

Repetition: count-controlled looping

Repetition: condition-controlled looping

Iteration over a data structure (looping through items)

Variables and constants in algorithms

One-dimensional data structures in algorithms (arrays, strings)

Two-dimensional data structures in algorithms (2D arrays/tables)

Records as a way to group related fields

Arithmetic operators in algorithms (modulus, integer division, exponentiation)

Relational operators in algorithms (comparisons)

Logical operators in algorithms (AND, OR, NOT)

Trace tables: tracking variable values step-by-step

Predicting the output for given test data

Types of errors: syntax, runtime and logic

Finding and fixing logic errors in an algorithm

Linear search: how it works and when to use it

Binary search: how it works and when to use it

Bubble sort: how it works and how many passes it needs

Merge sort: splitting and merging step-by-step

Choosing test data (normal, boundary and erroneous)

Judging fitness for purpose using logical reasoning + test data

Comparing algorithm efficiency (compares, loop passes, memory use)

Truth tables with AND, OR, NOT (up to three inputs)

Using truth tables to solve logic problems

Counting states: how many values a bit pattern can represent

Unsigned integers in binary

Two’s complement signed integers: what it represents

Converting denary to 8-bit binary (0 to 255)

Converting denary to 8-bit binary with two’s complement (-128 to +127)

Converting binary back to denary (unsigned and signed)

Binary addition (positive numbers)

Logical shifts: shifting bits and the effect on values

Arithmetic shifts: preserving sign in signed numbers

Overflow: when values don’t fit the available bits

Why hexadecimal is useful

Converting binary ↔ hexadecimal

Character encoding with 7-bit ASCII

Bitmap images: pixels, resolution and colour depth

Calculating bitmap image file size

Analogue sound concepts: amplitude and sampling

Sound representation: sample rate, bit depth and sample interval

Calculating sound file size

Limits of representation when bits are constrained (rounding/precision)

Storage units in binary multiples (bit to tebibyte)

File size and storage capacity calculations

Why compression is needed (storage + transmission)

Lossless vs lossy compression: what changes and when to use each

Lossless compression example: Run-Length Encoding (RLE)

Lossless compression example: Huffman coding (basic idea and purpose)

The CPU’s role in processing and control

Control unit: what it does in a CPU

ALU: what it does in a CPU

Registers: why they’re fast and what they store

RAM: purpose and why it’s needed while programs run

The system clock: why clock speed matters

Address bus, data bus and control bus (what each carries)

Fetch stage of the fetch-decode-execute cycle

Decode stage of the fetch-decode-execute cycle

Execute stage of the fetch-decode-execute cycle

Secondary storage: why it’s needed (non-volatile storage)

Magnetic storage: how it stores data and typical uses

Optical storage: how it stores data and typical uses

Solid state storage: how it stores data and typical uses

Choosing storage: speed, capacity, portability and cost trade-offs

Embedded systems: what they are

Embedded systems: real-world uses and constraints

Operating system jobs: file management

Operating system jobs: process management

Operating system jobs: peripheral management

Operating system jobs: user management

Utility software: file repair

Utility software: backup (including why it matters)

Utility software: data compression tools (what they do)

Utility software: disk defragmentation (why it’s used)

Utility software: anti-malware (what it protects against)

Robust software: why it matters

Finding vulnerabilities using audit trails

Finding vulnerabilities using code reviews

Low-level vs high-level languages: characteristics and purpose

Translators overview: why translation is needed

Compilers vs interpreters: key differences and impacts

LANs vs WANs: features and typical examples

How the internet is structured (routers + IP addressing)

IP addresses: what they are used for (basic purpose)

Routers: what they do in directing data

Wired vs wireless: speed, range, latency and bandwidth

Network speed units (bits per second: kilobit/megabit/gigabit)

Calculating transfer time from file size and transmission rate

Calculating required transmission rate for a given time limit

Why protocols are needed (standards for communication)

Ethernet and Wi-Fi: what they are used for

TCP/IP: why it matters as a protocol suite

HTTP vs HTTPS: what changes and why it matters

FTP: what it’s used for

Email protocols: SMTP, POP3 and IMAP (what each does)

TCP/IP 4-layer model: what a “layer” means

Application layer: what it’s responsible for

Transport layer: what it’s responsible for

Internet layer: what it’s responsible for

Link layer: what it’s responsible for

Bus topology: structure, strengths and weaknesses

Star topology: structure, strengths and weaknesses

Mesh topology: structure, strengths and weaknesses

Why network security matters

Network vulnerabilities: what they are and why they happen

Penetration testing: what it is used for

Ethical hacking: what it is and why it’s done

Access control as a protection method

Physical security as a protection method

Firewalls as a protection method

Environmental impacts of digital devices: manufacture of hardware

Environmental impacts of digital devices: replacement cycles

Environmental impacts of digital devices: disposal and e-waste

Personal data: what it is and why it’s valuable

Privacy risks from collecting personal data

Data ownership and consent (what “informed consent” looks like)

Misuse of personal data (common examples)

Data protection principles (what laws try to enforce)

AI/ML/robotics: what makes them ethically challenging

Accountability in AI decisions (who is responsible?)

Safety risks in automated systems

Algorithmic bias: how it happens and why it matters

Legal liability for AI/robotics failures (basic idea)

Copyright: protecting creative software and digital content

Patents: protecting inventions and technical ideas

Trademarks: protecting brand identity

Licensing: rules for using software legally

Malware overview: what it is and what it does

Viruses, worms and Trojans: how they differ

Ransomware: how it attacks and what it demands

Key loggers: what they capture and why

Exploiting unpatched software: why updates matter

Out-of-date anti-malware: why protection can fail

Social engineering: manipulating users to gain access

Protecting systems with anti-malware

Protecting data with encryption (basic purpose)

Acceptable use policies: what they do and why

Backup and recovery procedures: reducing damage after attacks

Using abstraction to decide what details to include in code

Reading code to understand purpose, inputs and outputs

Tracing program execution to predict outputs

Refining code for clarity and maintainability

Converting flowcharts into working programs

Converting pseudocode into working programs

Constants, variables, initialisation and assignment

Input, processing and output in a program

Sequence in real programs

Selection in real programs (if/else style decisions)

Repetition: count-controlled loops in programs

Repetition: condition-controlled loops in programs

Iteration through each item in a data structure

Single entry/exit code blocks (structured programming idea)

Primitive data types in code (integer, real, Boolean, char)

Strings: storing and using text

Arrays: storing multiple values in one structure

Two-dimensional arrays: storing grid/table data

Records: grouping fields for one “thing”

Choosing variables vs constants appropriately

String manipulation: length and positions

String manipulation: substrings

String manipulation: case conversion

Validating user input: length checks

Validating user input: presence checks

Validating user input: range checks

Validating user input: pattern checks

Authentication in code: ID/password and lookup approach

Writing programs that respond appropriately to user input

Reading from CSV text files

Writing to CSV text files

Arithmetic operators in programs (modulus and integer division)

Exponentiation in programs (when and why)

Relational operators in programs (comparisons)

Logical operators in programs (AND, OR, NOT)

Using pre-existing (built-in/library) subprograms appropriately

Writing procedures: structure and purpose

Writing functions: structure and purpose

Parameters and arguments: passing data into subprograms

Return values: getting data back from a function

Global vs local variables: scope and good practice

Debugging: spotting syntax errors quickly

Debugging: fixing runtime errors safely

Debugging: finding logic errors using test data