Chapter 13
Data Representation
User-Defined Data Types
Choosing and designing data types to fit a problem — enumerated types, sets, pointers and composite record types, and why user-defined types make programs clearer and safer.
File Organisation and Access
Serial, sequential and random (direct) file organisation — storing, updating and accessing records, including hashing a key to a file address.
Floating-Point Numbers
Real number representation — mantissa and exponent, normalised form, the precision–range trade-off, rounding errors and how many values can be represented.
Chapter 14
Communication and Internet Technologies
Protocols
The TCP/IP protocol suite — application, transport, internet and link layers, what each layer's protocols do, and why layering makes communication robust.
Circuit Switching, Packet Switching
How circuit-switched and packet-switched networks transmit data — dedicated paths vs routed packets, and the practical differences between the two approaches.
Chapter 15
Hardware and Virtual Machines
Processors, Parallel Processing and Virtual Machines
RISC design and pipelining, parallel processing with Flynn's classifications (SISD, SIMD, MISD, MIMD), massively parallel computers, and how virtual machines run intermediate code.
Boolean Algebra and Logic Circuits
Boolean algebra laws and simplification, Karnaugh maps, building and simplifying logic circuits, and sequential elements — SR and JK flip-flops.
Chapter 16
System Software
Purposes of an Operating System (OS)
How the OS manages the processor, memory, input/output and backing store — process scheduling, paging, segmentation, virtual memory, interrupts and the hardware support behind it all.
Translation Software
Assemblers, compilers and interpreters in depth — lexical, syntax and semantic analysis, code generation and optimisation, plus BNF, syntax diagrams and library routines.
Chapter 17
Security
Chapter 18
Artificial Intelligence (AI)
Chapter 19
Computational Thinking and Problem-Solving
Searching Algorithms
Locating data in a structure — linear search checking every item in turn, binary search halving a sorted list, and tracing both to see how many comparisons each needs.
Sorting Algorithms
Ordering data efficiently — insertion sort building a sorted list one item at a time and bubble sort repeatedly swapping neighbours, with traces of each pass.
Abstract Data Types (ADT)
Data structures defined by their behaviour — linked lists, binary trees, stacks and queues: what operations each supports and how each is implemented.
Algorithm Complexity
Measuring efficiency — Big-O notation for time and space, comparing constant, linear, logarithmic and polynomial growth, and classifying search & sort algorithms.
Recursion
Understanding base and general cases — writing, tracing and evaluating recursive algorithms, using the call stack, and knowing when recursion beats iteration.
Chapter 20
Further Programming
Programming Paradigms
Choosing the right paradigm — procedural, object-oriented (classes, inheritance, polymorphism, containment, class diagrams), low-level (addressing modes, assembly) and declarative programming.
ADT: Binary Tree
Visualising hierarchical data — nodes, branches and leaves, adding and searching values in a binary search tree, and the traversals that visit every node.
ADT: Linked List
Paper 4 ADT set — following the chain: nodes linked by pointers, traversing from the head, inserting and removing items without shifting data.
ADT: Queue
Paper 4 ADT set — first in, first out: enqueue and dequeue operations, circular-queue implementation with wrap-around, and where queues buffer real-world processing.
ADT: Stack
Paper 4 ADT set — last in, first out: push and pop on the top of the stack, peeking, overflow and underflow, and how stacks power call frames and undo.
File Handling
Working with files from code — opening, reading, writing and updating records, including random-file organisation and searching for data.
Exception Handling
Writing robust programs — throwing and catching exceptions, structured exception handlers and recovering gracefully from runtime errors.