Glossary

Every term the lessons explain: what it means, and the lesson that teaches it. 277 terms in all.

Data representation

Binary: A base-2 number system using only 0 and 1: the fundamental representation of all data in computers. Taught in Number Systems
Hexadecimal: A base-16 number system using 0-9 and A-F, commonly used as a compact shorthand for binary values. Taught in Number Systems
ASCII: American Standard Code for Information Interchange: a 7-bit encoding representing 128 characters (letters, digits, symbols). Taught in Representing Data
Unicode: A universal character encoding standard supporting over 140,000 characters from all writing systems worldwide. Taught in Representing Data
Lossy compression: Compression that permanently removes some data to achieve smaller files. Quality is reduced but not fully recoverable (e.g., JPEG, MP3). Taught in Compression
Lossless compression: Compression that reduces file size without losing any data. The original is perfectly reconstructed (e.g., PNG, ZIP). Taught in Compression
Sample rate: The number of audio samples captured per second (measured in Hz). Higher sample rate = more accurate digital representation. Taught in Representing Data
Colour depth: The number of bits used per pixel to represent colour. 8-bit = 256 colours, 24-bit = ~16.7 million colours. Taught in Representing Data
Bitmap: An image stored as a grid of pixels, each pixel's colour recorded as a binary value. File size = width x height x colour depth (in bits). Taught in Representing Data
Pixel: Picture element: one dot in a bitmap image. Each pixel stores one colour value in binary; 24-bit RGB gives 8 bits each for red, green, and blue. Taught in Representing Data

Hardware

CPU: Central Processing Unit. The primary component that executes instructions and processes data in a computer. Taught in CPU Architecture
ALU: Arithmetic Logic Unit. The part of the CPU that performs mathematical calculations and logical comparisons. Taught in CPU Architecture
FDE cycle: The Fetch-Decode-Execute cycle: the process by which the CPU retrieves an instruction from memory, interprets it, and carries it out. Taught in CPU Architecture
GPU: Graphics Processing Unit. A processor with many simple cores designed for parallel processing of graphics and data-intensive tasks. Taught in GPU
TPU: Tensor Processing Unit. A chip designed by Google specifically for neural-network calculations; a kind of ASIC. Taught in What Machine Learning Is
ASIC: Application-Specific Integrated Circuit. A chip built to do one fixed task with maximum efficiency; it cannot be reprogrammed after manufacture. Taught in What Machine Learning Is
FPGA: Field-Programmable Gate Array. A chip whose internal circuitry can be reconfigured after manufacture, trading some raw speed for flexibility. Taught in What Machine Learning Is
HPC: High-Performance Computing. Many machines linked together to work as one supercomputer, for workloads far too large for a single computer. Taught in What Machine Learning Is
RAM: Random Access Memory. Volatile primary memory that stores data and instructions currently in use by the CPU. Taught in Primary Memory
ROM: Read-Only Memory. Non-volatile memory that stores the startup (boot) instructions your computer needs to turn on. Data persists when power is off. Taught in Primary Memory
Cache: A small, fast memory between the CPU and RAM that stores frequently accessed data to reduce access time. Taught in Primary Memory
Register: A tiny, ultra-fast storage location inside the CPU used to hold data being immediately processed. Taught in CPU Architecture
Bus: A communication pathway that transfers data between components inside a computer (data bus, address bus, control bus). Taught in CPU Architecture
SSD: Solid State Drive. A secondary storage device with no moving parts, using flash memory. Faster and more durable than HDD. Taught in Secondary Storage
HDD: Hard Disk Drive. A secondary storage device using spinning magnetic platters and a read/write head. Cheaper per GB than SSD. Taught in Secondary Storage
Compiler: A translator that converts an entire source code file into machine code (or bytecode) before execution. Errors reported before running. Taught in Translation (HL)
Interpreter: A translator that converts and executes source code one line at a time. Errors found during execution, stopping at the first error. Taught in Translation (HL)
Control unit: The CPU component that fetches and decodes instructions and sends control signals that coordinate the ALU, registers, and buses. It directs the fetch-decode-execute cycle but performs no calculations itself. Taught in CPU Architecture
Multi-core: A CPU with multiple independent processing cores on one chip, each able to fetch, decode, and execute its own instructions, so several tasks run in true parallel. Taught in CPU Architecture
Pipelining: Overlapping the fetch, decode, execute, and write-back stages of several instructions so every CPU stage stays busy each cycle. Increases instruction throughput without raising the clock speed. Taught in CPU Architecture
Cache hit: When the data the CPU needs is already in cache, avoiding the slower trip to RAM. A high hit rate keeps the CPU fed with data at speed. Taught in Primary Memory
Cache miss: When requested data is not in cache, so the CPU must fetch it from slower RAM (or storage) and wait. Each miss stalls execution; cache design aims to make misses rare. Taught in Primary Memory
Cloud computing: Delivering computing resources (servers, storage, software) over the internet on demand, paying for what is used instead of owning and maintaining the hardware. Taught in Cloud Computing
Virtualization: Running multiple virtual machines on one physical computer, each behaving as an independent computer with its own operating system. Underpins cloud computing and raises hardware utilisation. Taught in Cloud Computing
SaaS: Software as a Service. Ready-to-use applications delivered over the internet (web email, online documents): the provider manages everything below the app, so the customer has the least control and the least responsibility. Taught in Cloud Computing
PaaS: Platform as a Service. A managed environment (operating system, runtime, tools) where developers deploy their own applications without managing servers. Balances control against convenience. Taught in Cloud Computing
IaaS: Infrastructure as a Service. Renting fundamental resources (virtual machines, storage, networks) from a cloud provider: the customer manages the operating system and software, gaining the most control and the most responsibility. Taught in Cloud Computing
NAS: Network-Attached Storage. A dedicated storage device connected to a network so multiple users and devices can access shared files. Common for backups and shared media libraries. Taught in Secondary Storage
Run-length encoding: A lossless compression method that replaces a run of repeated identical values with one copy of the value plus a count (AAAA becomes 4A). Works best on data with long runs, like simple graphics. Taught in Compression
Transform coding: A lossy compression technique that converts data into frequency components and discards those humans barely perceive. The basis of JPEG images and MP3 audio. Taught in Compression
Bytecode: Intermediate code produced by a compiler (like Java's javac) that is not machine code for any real CPU. A virtual machine interprets or JIT-compiles it, so one compiled file runs on any platform with a VM. Taught in Translation (HL)
JIT compilation: Just-In-Time compilation. Translating bytecode into native machine code while the program runs, so frequently executed code reaches compiled speed while keeping the portability of interpretation. Taught in Translation (HL)

Logic gates

AND gate: A logic gate that outputs 1 only when both inputs are 1. Boolean: A AND B. Taught in Logic Gates
OR gate: A logic gate that outputs 1 when at least one input is 1. Boolean: A OR B. Taught in Logic Gates
NOT gate: A logic gate that inverts its input: 0 becomes 1, 1 becomes 0. Boolean: NOT A. Taught in Logic Gates
Truth table: A table listing all possible input combinations for a logic expression and the resulting output for each. Taught in Logic Gates
NAND gate: A logic gate that outputs 0 only when both inputs are 1 (NOT AND). It is functionally complete: any logic circuit can be built from NAND gates alone. Taught in Logic Gates
NOR gate: A logic gate that outputs 1 only when both inputs are 0 (NOT OR). Taught in Logic Gates
XOR gate: Exclusive OR. A logic gate that outputs 1 when exactly one input is 1; equal inputs give 0. Used in binary addition circuits. Taught in Logic Gates
XNOR gate: Exclusive NOR. A logic gate that outputs 1 when both inputs are equal (both 0 or both 1): the inverse of XOR, used as an equality detector. Taught in Logic Gates
Karnaugh map: A grid arrangement of a truth table in which adjacent cells differ by one variable. Grouping the 1s into rectangles of size 1, 2, 4, or 8 reads off a simplified Boolean expression. Taught in Logic Gates
Boolean algebra: The algebra of the logic values 1 and 0 (true and false) with the operators AND, OR, and NOT. Rules such as identity, annulment, and De Morgan's laws simplify logic expressions and circuits. Taught in Logic Gates
Logic diagram: A circuit drawing built from standard gate symbols showing how logic gates combine to implement a Boolean expression. Read left to right from inputs to output. Taught in Logic Gates

Control systems

Sensor: A device that detects changes in the environment (temperature, light, pressure) and converts them into a signal the system can process. Taught in Control Systems
Actuator: A device that carries out a physical action (motor, heater, valve) in response to commands from a controller. Taught in Control Systems
Feedback loop: When a system measures its own output and adjusts automatically. Example: a thermostat checks the temperature and turns the heater on or off. Taught in Control Systems
Transducer: A device that converts one form of energy into another. In control systems both sensors (physical signal to electrical) and actuators (electrical to physical action) are transducers. Taught in Control Systems
Closed-loop system: A control system that uses feedback: sensors measure the output, the controller compares it with the target value, and the actuators adjust continuously. A thermostat is the classic example. Taught in Control Systems
Open-loop system: A control system that runs a fixed sequence without measuring its own output. No feedback means it cannot correct errors: a basic washing machine cycle runs the same whatever happens inside. Taught in Control Systems
Embedded system: A small computer built into a larger device to perform one dedicated function (microwave controller, car braking system). Typically low-power, real-time, and running fixed firmware. Taught in Control Systems

Programming

Variable: A named storage location in memory that holds a value which can change during program execution. Taught in Variables & Data Types
Data type: The kind of value a variable can hold (e.g., int, double, String, boolean), which determines what operations are valid. Taught in Variables & Data Types
String: A sequence of characters (text), such as a name or sentence. Compared with .equals(), not ==. Manipulated with .length(), .substring(), .charAt(). Taught in String Methods
Exception: An error that occurs during program execution (runtime), disrupting the normal flow. Handled with try/catch. Taught in Exception Handling
Selection: A control structure that chooses between different paths based on a condition (if, else if, else). Taught in Selection (if/else)
Iteration: A control structure that repeats a block of code (for loop, while loop) until a condition is met. Taught in Iteration (Loops)
Method: A reusable block of code that performs a specific task, defined with a name, parameters, and return type. Taught in Methods & Modularization
Parameter: A variable declared in a method header that receives a value (argument) when the method is called. Taught in Methods & Modularization
Scope: The region of code where a variable is accessible. Local variables exist only inside the method or block where they are declared. Taught in Methods & Modularization
Substring: A portion of a string extracted with substring(start, end): the start index is included, the end index is not, and indexes count from 0. Taught in String Methods
Type casting: Converting a value from one data type to another. Widening (int to double) happens automatically; narrowing (double to int) needs an explicit cast and truncates the decimal part. Taught in Variables & Data Types
Scanner: A Java class that reads input from the keyboard (System.in) or a file, with next(), nextLine(), nextInt() and similar methods. hasNext() checks whether more input remains. Taught in Variables & Data Types
Global variable: A variable declared at class level, accessible from every method in the class. Convenient but risky: any method can change it, so prefer local variables and parameters where possible. Taught in Methods & Modularization
Local variable: A variable declared inside a method or block. It exists only while that block runs and its scope ends at the closing brace, so other methods cannot see it. Taught in Methods & Modularization
Infinite loop: A loop whose condition never becomes false, or that never advances toward its stopping condition, so it runs forever. Usually caused by a missing update statement or a wrong condition. Taught in Iteration (Loops)
Debugging: Finding and fixing errors in a program using systematic techniques: print statements, trace tables, and breakpoint step-through. Taught in Debugging Strategies
Breakpoint: A marker set in a debugger that pauses the program at a chosen line, so you can inspect variable values and step through execution one line at a time. Taught in Debugging Strategies

Data structures

Array: A fixed-size, ordered collection of elements of the same type, accessed by index (starting at 0). Taught in 1D Arrays
ArrayList: A dynamic list that grows and shrinks automatically. Stores objects (not primitives), accessed with .get(i) and .size(). Taught in ArrayList
Stack: A LIFO (Last In, First Out) data structure. Elements are added (push) and removed (pop) from the top only. Taught in Stacks
Queue: A FIFO (First In, First Out) data structure. Elements are added at the back (enqueue) and removed from the front (dequeue). Taught in Queues
LIFO: Last In, First Out. The access order used by stacks. The most recently added item is the first one removed. Taught in Stacks
FIFO: First In, First Out. The access order used by queues. The first item added is the first one removed. Taught in Queues
Static data structure: A structure whose size is fixed when it is created, like an array: memory is allocated once and access is fast, but it cannot grow, and unused slots waste memory. Taught in ArrayList
Dynamic data structure: A structure that grows and shrinks at runtime, like an ArrayList or linked list: no size limit is declared up front, at the cost of resizing work or per-node overhead. Taught in ArrayList
2D array: An array of arrays forming a grid, accessed with two indexes as grid[row][column]. Used for tables, game boards, and images; traversed with nested loops. Taught in 2D Arrays
Wrapper class: The object version of a primitive type (int becomes Integer, double becomes Double) so primitive values can be stored in collections like ArrayList. Java boxes and unboxes automatically. Taught in ArrayList

Algorithms

Linear search: Searching by checking each element one by one from start to end. Works on unsorted data. O(n) time complexity. Taught in Searching Algorithms
Binary search: Searching a sorted collection by repeatedly halving the search space. O(log n) time complexity. Taught in Searching Algorithms
Bubble sort: A sorting algorithm that repeatedly swaps adjacent elements if they are in the wrong order. O(n^2) time complexity. Taught in Sorting Algorithms
Selection sort: A sorting algorithm that finds the minimum element and swaps it into the correct position, one element per pass. O(n^2). Taught in Sorting Algorithms
Big-O notation: A way to describe how much slower an algorithm gets as the input grows. O(n) = double input, double time. O(n^2) = double input, quadruple time. Taught in Big-O Notation
Recursion: When a method calls itself to solve a problem by breaking it into smaller identical sub-problems, with a base case to stop. Taught in Recursion
Quicksort: A fast sorting algorithm that picks a pivot value, splits the list into smaller/larger halves, and repeats recursively. Much faster than bubble sort on average. Taught in Quicksort
Base case: The condition in a recursive method that stops the recursion by returning a value directly, without making another recursive call. Taught in Recursion
Time complexity: How an algorithm's running time grows as the input size n grows, expressed in Big-O notation such as O(1), O(log n), O(n), O(n^2). It counts steps, not seconds, so it is independent of hardware. Taught in Big-O Notation
Space complexity: How much extra memory an algorithm needs as the input grows. An in-place sort is O(1) space; recursion uses O(depth) stack space. Taught in Big-O Notation
Recursive case: The part of a recursive method that calls itself on a smaller version of the problem, moving execution toward the base case. Taught in Recursion
Call stack: The stack of frames holding each active method call's local variables and return point. Every call pushes a frame and every return pops one, which is why runaway recursion overflows it. Taught in Recursion

File processing

CSV: Comma-Separated Values. A plain text file format where each line is a record and fields are separated by commas. Taught in Reading Files
BufferedReader: A Java class that reads text from a file efficiently using a buffer. Uses readLine() which returns null at end-of-file. Taught in Reading Files
FileWriter: A Java class that writes text to a file. Default mode overwrites; pass true as second argument for append mode. Taught in Writing Files
BufferedWriter: A Java class that buffers text output for efficiency and adds newLine(). Wraps a FileWriter and must be closed (or used in try-with-resources) so the buffer is flushed to disk. Taught in Writing Files
Append mode: Opening a file for writing so new data is added after the existing content instead of replacing it: new FileWriter(path, true) in Java, mode 'a' in Python. Taught in Writing Files
Try-with-resources: Declaring the file object inside try (...) so Java closes it automatically when the block ends, even if an exception is thrown. Replaces manually calling close() in a finally block. Taught in Reading Files

Object-oriented programming

Class: A blueprint or template that defines the attributes (data) and methods (behaviour) common to all objects of that type. Taught in Classes and Objects
Object: A specific instance of a class, created using the new keyword, with its own set of attribute values. Taught in Classes and Objects
Instantiation: Creating a new object from a class using the new keyword. Example: Student s = new Student("Alice", 90); Taught in Classes and Objects
Constructor: A special method (same name as the class, no return type) called automatically when an object is created to initialise its attributes. Taught in Constructors
Encapsulation: Bundling data and methods into one unit and restricting direct access by making attributes private and providing public getters/setters. Taught in Encapsulation
Inheritance: A mechanism where a child class (subclass) reuses attributes and methods from a parent class (superclass), modelling an is-a relationship. Taught in Inheritance
Polymorphism: A parent-type variable can hold different child-type objects, and Java automatically calls the correct version of an overridden method based on the actual object. Taught in Polymorphism
Method overriding: When a child class provides its own implementation of a method inherited from the parent, replacing the parent version for child objects. Taught in Method Overriding
Abstract class: A class declared with the abstract keyword that cannot be instantiated and may contain abstract methods that subclasses must implement. Taught in Abstract Classes
Interface: A contract specifying methods a class must implement, with no method bodies. A class can implement multiple interfaces. Taught in Interfaces
Aggregation: A has-a relationship where one object contains another, but the contained object can exist on its own. Example: a Kennel has a Dog, but the Dog can exist without the Kennel. Taught in Aggregation
Composition: A strong has-a relationship where the parts cannot exist without the whole. Example: a House has Rooms. Destroy the house, the rooms go too. Taught in Composition vs Inheritance
Getter: A public method that returns the value of a private attribute without modifying it (accessor method). Taught in Encapsulation
Setter: A public method that modifies a private attribute, often including validation to ensure the new value is valid (mutator method). Taught in Encapsulation
Static method: A method that belongs to the class itself, not to any instance. It cannot access instance variables or use this. Taught in Static Members
UML class diagram: A standardised three-section diagram showing a class's name, attributes (with types and visibility), and methods. Taught in UML Class Diagrams
Access modifier: A keyword (private, default, protected, public) that sets where a class member can be accessed from. private means this class only, public means anywhere: the enforcement mechanism of encapsulation. Taught in Access Modifiers
Information hiding: Keeping an object's internal data private so it can only be read or changed through public methods. Callers depend on the interface, not the implementation, protecting the integrity of object state. Taught in Encapsulation
Instance variable: A non-static variable declared in a class: every object gets its own copy, holding that object's state. Also called an attribute or field. Taught in Static Members
Static variable: A variable declared static, belonging to the class itself: one shared copy exists no matter how many objects are created. Used for counters and shared constants; also called a class variable. Taught in Static Members
Superclass: The parent class in inheritance: its attributes and methods are passed down to the classes that extend it. Also called the parent or base class. Taught in Inheritance
Subclass: The child class that extends a superclass, inheriting its accessible members and adding or overriding behaviour. Models an is-a relationship: every subclass object is a superclass object. Taught in Inheritance
Overloading: Defining several methods (or constructors) with the same name but different parameter lists in the same class. The compiler picks the matching version at compile time (static polymorphism). Contrast overriding, where a subclass replaces an inherited method with the same signature. Taught in Method Overriding
Design pattern: A named, reusable solution template for a recurring design problem, such as singleton, factory, or observer. A pattern communicates intent and structure, not ready-made code. Taught in OOP Terminology Reference
Singleton: A design pattern that ensures a class has exactly one instance and provides a global access point to it (private constructor plus a static getInstance() method). Used for shared resources like settings or a database connection. Taught in OOP Terminology Reference
Factory pattern: A design pattern where a creation method decides which concrete subclass to instantiate and returns it as the parent type. Centralises object-creation logic and hides it from the caller. Taught in OOP Terminology Reference
Observer pattern: A design pattern defining a one-to-many dependency: observers register with a subject and are notified automatically when its state changes. Decouples an event source from the objects reacting to it; common in GUIs. Taught in OOP Terminology Reference

Abstract data types

Abstract data type: A high-level description of a data structure: the operations it supports and how they behave, independent of implementation. A stack is push, pop, and peek whether it is built on an array or a linked list. Taught in What Are ADTs?
Linked list: A dynamic structure of nodes, each holding data and a reference to the next node. It grows one node at a time, with fast insertion and deletion but only sequential access (no indexing). Taught in Linked Lists
Binary search tree: A binary tree where every node's left subtree holds smaller values and its right subtree larger values. This ordering makes search, insert, and delete O(log n) while the tree stays balanced. Taught in Binary Search Trees
In-order traversal: Visiting a binary search tree's nodes left subtree, then node, then right subtree, which outputs the values in ascending order. Pre-order visits the node first; post-order visits it last. Taught in BST Operations
Hash table: A structure storing key-value pairs in an array of buckets: a hash function converts each key to an index, giving average O(1) lookup, insert, and delete. Collisions are handled by chaining or probing. Taught in Sets and HashMaps
Hash function: A function that converts a key into a bucket index, for example hashCode() mod the array length. A good one is fast, deterministic, and spreads keys evenly across the buckets. Taught in Sets and HashMaps
Collision resolution: What a hash table does when two keys hash to the same index: chaining stores a small list in each bucket, while open addressing (probing) finds the next free slot. Taught in Sets and HashMaps
Load factor: How full a hash table is: entries divided by buckets. When it passes a threshold (0.75 in Java) the table resizes and rehashes so collisions stay rare. Taught in Sets and HashMaps
HashMap: Java's hash-table implementation of key-value pairs: put(key, value), get(key), containsKey(). Keys are unique and operations average O(1). Python's equivalent is dict. Taught in Sets and HashMaps
HashSet: Java's hash-based collection of unique elements: add(), contains(), and remove() all average O(1), and duplicates are silently ignored. Python's equivalent is set. Taught in Sets and HashMaps

Operating systems

Operating system: The software that manages your computer's hardware and lets you run applications. Handles memory, files, security, and device communication. Taught in OS Fundamentals
Scheduling: The OS function that decides which process gets CPU time and for how long, using algorithms like FCFS, Round Robin, or Priority. Taught in Scheduling
Interrupt: A signal that tells the CPU to stop what it is doing and handle an urgent event (e.g., a key press or mouse click), then return to the previous task. Taught in Polling and Interrupts
Polling: A technique where the CPU repeatedly checks each device in turn to see if it needs attention. Simple but wastes CPU cycles. Taught in Polling and Interrupts
Deadlock: A situation where two or more processes are blocked forever, each waiting for a resource held by the other. Taught in Multitasking
Virtual memory: A memory management technique that uses hard drive space as overflow when RAM is full, allowing programs larger than physical RAM to run. Taught in Primary Memory
Multitasking: Running several tasks apparently at once by switching the CPU between them rapidly (time slicing). The OS scheduler decides which task runs next and manages contention for shared resources. Taught in Multitasking
Context switching: Saving the state (registers, program counter) of the running process and loading another's, so the CPU can move between tasks. Enables multitasking, but every switch costs time with no useful work done. Taught in Multitasking
Round robin: A preemptive scheduling algorithm that gives each process a fixed time slice (quantum) in circular order. Fair and responsive for interactive systems; frequent context switches add overhead. Taught in Scheduling
FCFS: First-Come, First-Served. A non-preemptive scheduling algorithm that runs processes strictly in arrival order. Simple and fair by arrival, but short jobs can wait behind long ones (the convoy effect). Taught in Scheduling

Databases

Object-relational impedance mismatch: The friction between how OOP code models data (as objects with direct references, inheritance, and collections) and how a relational database stores the same data (as flat rows split across joined tables). Translating between the two takes glue code (ORMs like Hibernate) and often forces compromises in either the class design or the schema. Taught in Relational Database Fundamentals
Referential integrity: The rule that every foreign-key value must match an existing primary-key value in the referenced table. The DBMS rejects updates or inserts that would create orphan rows pointing to nothing. Taught in Data Types and Keys
Normalisation: The process of arranging columns into tables so each fact is stored in exactly one place. Stages 1NF, 2NF, 3NF progressively eliminate atomicity violations, partial-key dependencies, and transitive dependencies. Taught in Normalisation
Denormalisation: Deliberately re-introducing redundancy into a normalised schema to make read-heavy queries faster. Trades higher write cost and risk of inconsistency for read performance. Taught in Normalisation
Primary key: The column (or small set of columns) whose value uniquely identifies each row in a table. Cannot be null, cannot be duplicated. Taught in Data Types and Keys
Foreign key: A column in one table whose values must match a primary-key value in another table. The mechanism by which the relational model links tables together. Taught in Data Types and Keys
Composite key: A primary key made of two or more columns together. Used when no single column is unique on its own. The combination must be unique; individual columns may repeat. Taught in Data Types and Keys
ERD: Entity-Relationship Diagram. A visual notation for the entities (tables) a database tracks, their attributes, and the relationships between them, including cardinality (1:1, 1:M, M:M) and modality (mandatory or optional). Taught in Entity-Relationship Diagrams
Cardinality: The maximum number of instances on each side of a relationship: one-to-one (1:1), one-to-many (1:M), or many-to-many (M:M). Taught in Entity-Relationship Diagrams
Modality: Whether participation in a relationship is mandatory (an instance must take part) or optional (it may have zero links). Combines with cardinality to give a complete picture of a relationship. Taught in Entity-Relationship Diagrams
DDL: Data Definition Language. The subset of SQL that defines database structure: CREATE TABLE, ALTER TABLE, DROP TABLE, CREATE INDEX. Taught in SQL Queries
DML: Data Manipulation Language. The subset of SQL that reads and modifies data: SELECT, INSERT, UPDATE, DELETE. Taught in SQL Queries
ACID: Atomicity, Consistency, Isolation, Durability. The four properties that together describe what a database transaction guarantees: all-or-nothing, valid state to valid state, no interference between concurrent transactions, and survival of committed changes through failures. Taught in Transactions and Views (HL)
OLAP: Online Analytical Processing. The interactive aggregation layer that lets analysts slice, dice, drill down, and pivot multi-dimensional data in a data warehouse. Contrasts with OLTP (transactional, day-to-day reads and writes). Taught in Data Warehouses (HL)
Relational database: A database that stores data in tables (relations) of rows and columns, links tables with primary and foreign keys, and enforces integrity rules. Queried with SQL. Taught in Relational Database Fundamentals
Database schema: The formal description of a database's structure at three levels: conceptual (what data the business needs), logical (tables, keys, types), and physical (storage and indexes). Taught in Database Schemas
Functional dependency: Column B is functionally dependent on column A when each value of A determines exactly one value of B (written A -> B). Normalisation analyses these dependencies to decide which columns belong in which table. Taught in Normalisation
Data warehouse: A central store of historical data integrated from multiple operational systems, structured for analysis (OLAP) rather than day-to-day transactions. Subject-oriented, integrated, time-variant, and non-volatile. Taught in Data Warehouses (HL)
Data mining: Automatically discovering previously unknown patterns in large data sets, using techniques such as classification, clustering, association rules, and anomaly detection, to support business decisions. Taught in Data Warehouses (HL)
OLTP: Online Transaction Processing. The day-to-day operational workload: many small, fast reads and writes (orders, bookings) on a normalised database. Contrast OLAP's large analytical queries over history. Taught in Data Warehouses (HL)
NoSQL: Databases that drop the fixed-schema relational model (document, key-value, graph, and column stores) to scale horizontally and handle unstructured or fast-changing data, typically trading strict consistency for availability. Taught in Alternative Databases (HL)
Transaction: A sequence of database operations executed as one all-or-nothing unit, like a transfer's debit plus credit. COMMIT makes it permanent, ROLLBACK undoes it, and the ACID properties guarantee integrity. Taught in Transactions and Views (HL)
Materialised view: A view whose result set is physically stored as a snapshot and refreshed periodically. Fast to query but can serve stale data, unlike a virtual view computed fresh on every query. Taught in Transactions and Views (HL)
Aggregate function: An SQL function that computes one value from many rows: COUNT, SUM, AVG, MAX, MIN. Combined with GROUP BY to summarise each group of rows. Taught in SQL Queries
Distributed database: A single logical database whose data is stored across multiple physical sites. Key features: replication, partitioning, concurrency control, consistency, transparency, fault tolerance, security, and scalability. Taught in Distributed Databases (HL)
Replication: Keeping synchronised copies of data at multiple sites so the system survives node failures and reads can be served locally. The cost is keeping every copy consistent after writes. Taught in Distributed Databases (HL)
Partitioning: Splitting a database into parts stored on different sites, by rows (horizontal) or by columns (vertical), so each site handles a share of the data and load. Taught in Distributed Databases (HL)
Sharding: Horizontal partitioning: each shard holds a subset of rows (customers A-M, for example), letting a huge database scale across many servers. Taught in Distributed Databases (HL)
Concurrency control: Mechanisms such as locking and timestamps that let multiple transactions run at the same time without corrupting data: they prevent lost updates and dirty reads, preserving isolation. Taught in Transactions and Views (HL)

Machine learning

Machine learning: Building systems that learn patterns from data and improve with experience, instead of following rules a programmer wrote by hand. The behaviour comes from training on examples, not explicit programming. Taught in What Machine Learning Is
Training data: The examples a model learns from during training; in supervised learning each one is labelled with the correct answer. Its quality and coverage largely determine the model's quality, and its biases. Taught in What Machine Learning Is
Test data: Data held back from training and used only to measure how well the model generalises to unseen examples. The train/test split is the basic defence against overfitting. Taught in Training and Evaluating a Model
Supervised learning: Learning from labelled examples (input plus correct answer) so the model can predict labels for new data. Produces classifiers for discrete categories and regression models for continuous values. Taught in What Machine Learning Is
Unsupervised learning: Learning from unlabelled data: the algorithm finds structure on its own, grouping similar items (clustering) or finding co-occurrence patterns (association rules). No correct answers are provided. Taught in What Machine Learning Is
Reinforcement learning: An agent learns by interacting with an environment: it acts, receives rewards or penalties, and updates its policy to maximise cumulative reward, balancing exploration of new actions against exploitation of known good ones. Taught in What Machine Learning Is
Deep learning: Machine learning with neural networks of many layers, which learn increasingly abstract features of raw data (edges, then shapes, then objects). Powers modern image and language systems; needs large data and compute. Taught in What Machine Learning Is
Transfer learning: Starting from a model already trained on a large general task and fine-tuning it for a related specific task. Saves data, time, and energy compared with training from scratch. Taught in What Machine Learning Is
Perceptron: The simplest artificial neuron: it multiplies each input by a weight, sums them with a bias, and applies an activation function to produce the output. Training adjusts the weights to reduce error. Taught in What Machine Learning Is
Neural network: A network of artificial neurons arranged in layers (input, hidden, output), where every connection has a learned weight. Stacking layers lets it learn complex non-linear patterns; the multi-layer perceptron is the basic form. Taught in What Machine Learning Is
Data cleaning: Fixing or removing dirty data before training: handling missing values, correcting errors, removing duplicates and outliers. Model quality depends on it: garbage in, garbage out. Taught in Training and Evaluating a Model
Feature selection: Choosing which input variables the model should learn from, using filter, wrapper, or embedded methods. Fewer, more relevant features mean faster training and less overfitting. Taught in Training and Evaluating a Model
Dimensionality reduction: Reducing the number of features while keeping the information that matters, by combining or transforming them. Makes patterns easier to learn and data easier to visualise. Taught in Training and Evaluating a Model
Linear regression: A supervised technique that fits a straight line through the data to predict a continuous outcome. Training minimises the total prediction error between the line and the points. Taught in Training and Evaluating a Model
Overfitting: The model learns the training data too specifically, noise included, so it scores highly on training data but poorly on unseen test data. Detected by a large gap between training and test performance. Taught in Training and Evaluating a Model
Underfitting: The model is too simple to capture the underlying pattern, so it performs poorly even on the training data. Fixed with a more complex model or more informative features. Taught in Training and Evaluating a Model
Hyperparameter: A setting chosen before training rather than learned from the data, such as k in k-NN or the depth of a decision tree. Tuned by comparing model performance across different values. Taught in Training and Evaluating a Model
F1 score: The harmonic mean of precision and recall: one score that balances false positives against false negatives. Preferred over plain accuracy when the classes are imbalanced. Taught in Training and Evaluating a Model
Confusion matrix: A table of predicted versus actual classes, counting true and false positives and negatives. Accuracy, precision, and recall are all calculated from it. Taught in Training and Evaluating a Model
CNN: Convolutional Neural Network. A deep network for images: convolutional layers slide small filters across the image to detect features, pooling layers shrink the maps, and fully connected layers classify. Learns a spatial hierarchy from edges to objects. Taught in Training and Evaluating a Model
K-NN: k-Nearest Neighbours. Classifies a new point by majority vote of its k closest labelled examples, measured by distance. Simple and training-free, but slow at prediction time and sensitive to the choice of k. Taught in Types of Learning
Decision tree: A supervised model that predicts by asking a sequence of yes/no questions about the features, drawn as a tree whose leaves are the predictions. Easy to interpret and explain. Taught in Types of Learning
Clustering: Unsupervised grouping of data so items in a cluster are similar to each other and different from other clusters. Used for customer segmentation and pattern discovery when no labels exist. Taught in Types of Learning
K-means: A clustering algorithm: choose k centroids, assign every point to its nearest centroid, recompute the centroids, and repeat until stable. k must be chosen in advance. Taught in Types of Learning
Association rule: An if-then pattern mined from data (customers who buy X also tend to buy Y), scored by support and confidence. The classic technique behind market basket analysis. Taught in Types of Learning
Genetic algorithm: An optimisation technique inspired by evolution: a population of candidate solutions is scored by a fitness function, and the fittest are selected, combined (crossover), and randomly tweaked (mutation) over generations until termination. Taught in Types of Learning
Fitness function: The scoring function in a genetic algorithm that measures how good each candidate solution is. Selection pressure comes from preferring higher-fitness candidates for the next generation. Taught in Types of Learning

Networks

LAN: Local Area Network. A network covering a small geographic area like a single building or campus. Taught in Network Fundamentals
WAN: Wide Area Network. A network spanning a large geographic area, connecting multiple LANs. Taught in Network Fundamentals
TCP: Transmission Control Protocol: a connection-oriented protocol that ensures reliable, ordered delivery of data. Taught in Protocols and Layers
UDP: User Datagram Protocol. A connectionless protocol that sends data without guaranteeing delivery, used when speed matters most. Taught in Protocols and Layers
IP address: A unique numerical address assigned to each device on a network (e.g., 192.168.1.1), used to identify and locate it. Taught in Data Transmission
DNS: Domain Name System. Translates human-readable domain names (e.g., google.com) into IP addresses. Taught in Network Architecture
HTTP: HyperText Transfer Protocol. The application-layer protocol for transferring web pages between browsers and servers. Taught in Protocols and Layers
HTTPS: HTTP Secure. HTTP encrypted with TLS/SSL to protect data in transit between client and server. Taught in Protocols and Layers
Firewall: A network security device or software that monitors and filters incoming/outgoing traffic based on predefined rules. Taught in Network Security
Packet: A small unit of data transmitted over a network, containing a header (source, destination, sequence number) and a payload. Taught in Data Transmission
Protocol: A set of agreed rules governing how data is formatted, transmitted, and received across a network. Taught in Protocols and Layers
MAC address: Media Access Control address: a unique hardware identifier built into every network device (like a serial number), used to identify devices on a local network. Taught in Network Fundamentals
Encryption: The process of converting readable data (plaintext) into unreadable form (ciphertext) using an algorithm and key. Taught in Encryption
Symmetric encryption: Encryption where the same secret key is used for both encryption and decryption. Fast, but requires secure key exchange. Taught in Encryption
Asymmetric encryption: Encryption using two keys. A public key (shared openly) to encrypt, and a private key (kept secret) to decrypt. Slower but more secure to set up. Taught in Encryption
VPN: Virtual Private Network. Creates an encrypted tunnel over a public network, allowing secure remote access to a private network. Taught in Network Fundamentals
PAN: Personal Area Network. A network covering a few metres around one person, typically Bluetooth links between a phone, earbuds, and a watch. Very short range, low power. Taught in Network Fundamentals
Edge computing: Processing data near where it is generated (on or close to the device) instead of sending everything to distant cloud servers. Cuts latency and bandwidth use; important for IoT and real-time systems. Taught in Network Fundamentals
Distributed system: Multiple networked computers working together while appearing to users as a single system. Offers scalability and fault tolerance at the cost of coordination complexity. Taught in Network Fundamentals
Router: A device that forwards packets between different networks, choosing each packet's next hop using IP addresses and a routing table. Connects a LAN to the internet. Taught in Network Fundamentals
Switch: A network device that connects devices within one LAN and forwards data only to the port of the intended recipient, using learned MAC addresses. More efficient than a hub, which broadcasts to every port. Taught in Network Fundamentals
Modem: Modulator-demodulator. Converts digital signals to analogue for transmission over telephone or cable lines and converts them back at the other end: the bridge between a home network and the ISP. Taught in Network Fundamentals
NIC: Network Interface Card. The hardware that connects a device to a network, wired or wireless, and holds its unique MAC address. Taught in Network Fundamentals
Gateway: A device that connects networks using different protocols and translates between them. In home networks it is usually combined with the router: the default gateway is the exit point of the LAN. Taught in Network Fundamentals
Wireless access point: A device that broadcasts a Wi-Fi signal so wireless devices can join a wired network. Extends network coverage; connects back to the switch by cable. Taught in Network Fundamentals
DHCP: Dynamic Host Configuration Protocol. Automatically assigns (leases) an IP address and network settings to each device joining a network, avoiding manual configuration and address clashes. Taught in Protocols and Layers
TCP/IP model: The four-layer networking model: application, transport, internet, and network interface. Each layer adds its own header (encapsulation) and provides services to the layer above it. Taught in Protocols and Layers
IPv4: The 32-bit IP addressing scheme written as four numbers 0-255 (such as 192.168.1.10). Only about 4.3 billion addresses exist, hence NAT and the move to IPv6. Taught in Data Transmission
IPv6: The 128-bit IP addressing scheme written as eight groups of hexadecimal digits. Provides an effectively unlimited address space, removing the need for NAT. Taught in Data Transmission
NAT: Network Address Translation. The router rewrites private IP addresses to its single public address and tracks each connection, letting many devices share one public IPv4 address while hiding internal addresses from outside. Taught in Data Transmission
Packet switching: Splitting a message into packets that are routed independently across the network and reassembled in order at the destination using sequence numbers. Efficient (links are shared) and fault-tolerant (packets route around failures). Taught in Data Transmission
Static routing: Routes entered manually by an administrator that never change on their own. Predictable and low-overhead, but cannot adapt when a link fails; suits small, stable networks. Taught in Data Transmission
Dynamic routing: Routers exchange information and update their routing tables automatically, adapting to failures and congestion. More resilient than static routing, at the cost of overhead and complexity. Taught in Data Transmission
Bandwidth: The maximum amount of data a connection or channel can transfer per second, measured in bits per second. Higher bandwidth moves more data at once; it does not shorten the journey of each individual bit. Taught in Data Transmission
Latency: The delay between an action or request and its response, measured in milliseconds. In networks it depends on distance, hops, and congestion; low latency matters for calls and gaming. Taught in Network Fundamentals
Star topology: Every device connects to a central switch. Easy to manage and one cable failure affects only that device, but the central device is a single point of failure. Taught in Network Architecture
Mesh topology: Each node connects to several others (in a full mesh, to all), giving multiple redundant paths. Highly fault-tolerant but expensive to cable and manage; used in backbones and Wi-Fi mesh systems. Taught in Network Architecture
Client-server: A networking model where dedicated servers provide services and clients request them. Gives central control, easier security and backups; the server is a bottleneck and single point of failure. Taught in Network Architecture
Peer-to-peer: A networking model where every device acts as both client and server, sharing resources directly. Cheap and resilient with no central dependency, but harder to secure and manage centrally. Taught in Network Architecture
Subnetting: Dividing an IP network into smaller sub-networks. Reduces broadcast traffic, improves security by isolating groups, and organises addressing (by floor, department, or function). Taught in Network Architecture
VLAN: Virtual LAN. A logical grouping of devices configured on switches that behaves as its own separate LAN regardless of physical location. Isolates traffic without re-cabling. Taught in Network Architecture
Proxy server: A server that forwards requests between clients and the internet. It can cache pages to save bandwidth, filter content, log activity, and hide internal addresses. Taught in Network Architecture
DDoS: Distributed Denial of Service. Flooding a target with traffic from many compromised machines (a botnet) so its bandwidth or resources are exhausted and legitimate users are denied service. Taught in Network Security
Malware: Malicious software designed to damage, disrupt, or gain unauthorised access to a system. Includes viruses, worms, trojans, ransomware, and spyware. Taught in Network Security
Phishing: Tricking users into revealing credentials or installing malware through fraudulent messages that impersonate trusted organisations. Attacks the human, not the technology; countered by training and MFA. Taught in Network Security
Man-in-the-middle: An attack where a third party secretly intercepts, and can alter, traffic between two parties who believe they are communicating directly. Encryption with authenticated certificates is the main defence. Taught in Network Security
SQL injection: Entering SQL fragments into input fields so they execute against the database, exposing or destroying data. Prevented by input validation and parameterised queries. Taught in Network Security
XSS: Cross-Site Scripting. Injecting malicious script into a trusted website so it runs in other users' browsers, stealing sessions or data. Prevented by validating and escaping user input. Taught in Network Security
Zero-day: A vulnerability unknown to the software vendor, exploited before any patch exists (the vendor has had zero days to fix it). Defences rely on behaviour-based detection rather than known signatures. Taught in Network Security
Intrusion detection system: An IDS monitors network traffic for suspicious patterns and alerts administrators. It detects but does not block; compare an IPS, which sits in-line and can stop the traffic. Taught in Network Security
Intrusion prevention system: An IPS sits in the traffic path and automatically blocks detected attacks in real time: an IDS that can act, at the risk of blocking legitimate traffic on a false positive. Taught in Network Security
MFA: Multi-Factor Authentication. Requiring two or more independent proofs of identity from different categories (something you know, have, or are), so a stolen password alone is not enough. Taught in Network Security
TLS: Transport Layer Security, successor to SSL. The protocol that encrypts internet traffic (the S in HTTPS): a handshake authenticates the server with a certificate and agrees a symmetric session key. Taught in Encryption
Digital certificate: An electronic document, signed by a trusted Certificate Authority, that binds a public key to an identity such as a website. Lets a browser verify it is talking to the real server before encrypting. Taught in Encryption
Digital signature: A hash of a message encrypted with the sender's private key. Anyone can verify it with the matching public key, proving who sent the message (authenticity) and that it was not altered (integrity). Taught in Encryption

Computational thinking

Abstraction: Focusing on essential information and ignoring unnecessary detail to simplify a problem. Taught in CT Concepts
Decomposition: Breaking a complex problem into smaller, manageable sub-problems that can be solved independently. Taught in CT Concepts
Pattern recognition: Identifying similarities, trends, or repeated structures across problems or data. Taught in CT Concepts
Algorithmic thinking: Designing a clear, step-by-step sequence of instructions to solve a problem. Taught in CT Concepts
Problem specification: A structured description of a problem including statement, constraints, objectives, goals, inputs, outputs, and evaluation criteria. Taught in Problem Specification
Flowchart: A visual diagram using standard symbols (oval, rectangle, diamond, parallelogram) to represent the steps in an algorithm. Taught in Flowcharts
Pseudocode: A plain-language description of an algorithm using programming-style structure (sequence, selection, iteration) without any real language's exact syntax. Used to plan and communicate logic before coding. Taught in Pseudocode
Algorithm: A finite, ordered sequence of unambiguous steps that solves a problem. The same algorithm can be expressed in pseudocode, a flowchart, or any programming language. Taught in CT Concepts
Trace table: A table recording the value of every variable (and any output) after each step of a program. Used to follow execution by hand, predict output, and locate logic errors. Taught in Debugging Strategies
Sentinel value: A special input value (such as -1 or STOP) that marks the end of data entry, letting a conditional loop know when to stop. Chosen from outside the range of valid data. Taught in Flowcharts

Ethics

Digital divide: The gap between people who have access to devices, connectivity, and digital skills and those who do not. Computing's benefits are unevenly distributed by income, geography, and age, raising equity questions. Taught in Computing in Daily Life
Quantum computing: Computing with qubits that use superposition and entanglement to explore many possibilities at once. Promises breakthroughs in simulation and threatens current encryption; practical machines are still limited. Taught in Computing in Daily Life
Augmented reality: Overlaying digital information onto the real world through a phone or headset, like navigation arrows on the street. Raises privacy questions because the device can record everything the user sees. Taught in Computing in Daily Life
Virtual reality: A fully computer-generated environment experienced through a headset that replaces the user's view of the real world. Used in training, gaming, and therapy. Taught in Computing in Daily Life