Cambridge Syllabus Notes

1 Information Representation

1.1 Number Systems

Binary (base‑2) – digits 0, 1. Used internally by all computers.
Octal (base‑8) – digits 0‑7. Often used as a shorthand for groups of three binary bits.
Decimal (base‑10) – digits 0‑9. Human‑friendly.
Hexadecimal (base‑16) – digits 0‑9, A‑F. Convenient for representing bytes (two hex digits = 8 bits).

1.2 Conversions (quick methods)

From → To	Method
Binary → Decimal	Sum of 2ⁿ for each ‘1’ bit (right‑most bit = 2⁰).
Decimal → Binary	Repeated division by 2, record remainders (read upwards).
Binary ↔ Hexadecimal	Group bits in sets of four (starting from the right) and replace each group with its hex digit.
Octal ↔ Binary	Group bits in sets of three.

1.3 Signed Numbers – Two’s Complement

Positive numbers: same as unsigned binary.
Negative numbers: invert all bits and add 1.
Range for an n-bit word: –2ⁿ⁻¹ to 2ⁿ⁻¹ – 1.

Example: 8‑bit representation of –25

25 = 0001 1001
Invert → 1110 0110
Add 1 → 1110 0111 (‑25)

1.4 Character Encodings

ASCII – 7‑bit code for 128 characters (basic English letters, digits, control codes).
Extended ASCII – 8‑bit, adds 128 extra symbols (e.g., accented letters).
Unicode (UTF‑8) – variable‑length encoding covering > 140 000 characters; backward compatible with ASCII.

1.5 Data Compression

Lossless – original data can be perfectly reconstructed (e.g., Run‑Length Encoding, Huffman coding).
Lossy – some information discarded for higher compression (e.g., JPEG for images, MP3 for audio).

2 Communication

2.1 Core Networking Concepts

2.1.1 Devices and Their Roles

Router – connects different networks, forwards packets using IP addresses, performs NAT and routing table look‑ups.
Switch – interconnects devices within a LAN, forwards frames using MAC addresses, reduces collisions.
Hub – simple multi‑port repeater; broadcasts incoming signals to all ports (high collision domain, largely obsolete).
Network Interface Card (NIC) – provides a unique MAC address and the physical link (wired or wireless) to the network.

2.1.2 LAN vs. WAN

Aspect	LAN	WAN
Geographic scope	Single building or campus	City, country, or global
Typical media	Ethernet (Cat 5e/6/7), Wi‑Fi (802.11)	Fiber‑optic, leased lines, satellite, MPLS
Common protocols	Ethernet, TCP/IP, DHCP, DNS	Frame Relay, ATM, MPLS, VPN over TCP/IP
Typical speed	10 Mbps – 10 Gbps	1 Mbps – 100 Gbps (provider‑dependent)
Examples	School computer lab, office floor	Bank branch network, Internet backbone

2.1.3 Network Topologies

Bus – single cable; cheap and easy to implement but a break disables the whole network.
Star – each node connects to a central switch/hub; fault isolation is simple; requires more cable.
Mesh – every node has a direct link to others; high reliability and redundancy; expensive and complex.
Hybrid – combination of two or more topologies (e.g., star‑bus); balances cost and performance.

2.1.4 IP Addressing & Subnetting

IPv4 – 32‑bit address written as four octets (e.g., 192.168.1.10). Supports ~4.3 billion addresses.
IPv6 – 128‑bit address written in eight groups of four hexadecimal digits (e.g., 2001:0db8:85a3::8a2e:0370:7334). Vast address space.
Subnet mask – determines the network and host portions of an IPv4 address (e.g., 255.255.255.0 = /24).
CIDR notation – compact representation of address + mask (e.g., 10.0.0.0/8).

2.1.5 Common Protocols (TCP/IP Stack)

Layer	Protocol(s)	Purpose
Application	HTTP, HTTPS, FTP, SMTP, DNS, SSH	End‑user services
Transport	TCP (reliable), UDP (low‑latency)	Port‑to‑port communication
Internet	IP, ICMP, IPv4, IPv6	Routing of packets
Link	Ethernet, Wi‑Fi (IEEE 802.11), PPP	Physical media access

2.1.6 Client‑Server vs. Peer‑to‑Peer (P2P)

Client‑Server – centralised server provides resources; clients request services.
- Example: Web browsing – browser (client) requests pages from a web server.
- Advantages: Centralised control, easier security management, scalable with powerful servers.
Peer‑to‑Peer – each node can act as both client and server, sharing resources directly.
- Example: BitTorrent – pieces of a file are downloaded from many peers simultaneously.
- Advantages: Distributed load, lower central infrastructure cost; challenges include security and reliability.

2.1.7 Thin‑Client vs. Thick‑Client (Fat‑Client)

Thin‑client – minimal processing/storage; most applications run on a remote server. Example: University computer‑lab terminals displaying virtual desktops from a data centre.
Thick‑client – full‑featured workstation with its own CPU, memory, storage; runs applications locally. Example: Student laptop running Microsoft Office.

2.1.8 Wired vs. Wireless Links

Aspect	Wired (Ethernet)	Wireless (Wi‑Fi, Bluetooth)
Medium	Copper (Cat 5e/6/7) or fibre‑optic cable	Radio waves (2.4 GHz, 5 GHz, 60 GHz)
Typical bandwidth	Up to 10 Gbps (or higher with fibre)	Up to 1.2 Gbps (Wi‑Fi 6/6E)
Reliability	Very high – immune to most interference	Subject to interference, signal loss, security concerns
Installation cost	Higher cabling cost, low maintenance	Lower physical installation, need AP management
Typical use‑case	Backbone links, data‑centres, desktop connections	Mobile devices, laptops on campus, IoT sensors

2.2 Cloud Computing – Core Concepts

2.2.1 Definition

Cloud computing delivers computing resources (hardware, software, storage, and services) over a network—normally the Internet—on a pay‑as‑you‑go basis. The Internet (TCP/IP) provides the transport that connects end‑users to remote data centres, making the cloud globally accessible.

2.2.2 NIST Characteristics

On‑demand self‑service
Broad network access (any Internet‑connected device)
Resource pooling (multi‑tenant architecture)
Rapid elasticity & scalability
Measured service (pay‑per‑use)

2.2.3 Service Models

Model	Provider Supplies	Consumer Manages	Typical Use‑Cases
IaaS (Infrastructure as a Service)	Virtual machines, storage, networking, hypervisor	Operating system, middleware, runtime, data, applications	Web‑site hosting, disaster‑recovery, big‑data processing
PaaS (Platform as a Service)	OS, middleware, runtime, development tools	Applications and data	Rapid application development, test environments
SaaS (Software as a Service)	Complete applications delivered via the web	User‑level configuration and data	Email, CRM, office productivity suites

2.2.4 Deployment Models

Public Cloud – owned/operated by a third‑party provider; resources shared among many organisations.
Private Cloud – dedicated infrastructure for a single organisation (on‑premises or hosted).
Hybrid Cloud – integration of public and private clouds; workloads can move between them.
Community Cloud – shared by several organisations with common concerns (e.g., regulatory compliance).

2.2.5 Advantages

Cost reduction – no capital expenditure on hardware.
Scalability – resources can be expanded or reduced instantly.
Accessibility – services available from any Internet‑connected device.
Reliability – providers offer high availability, redundancy, and disaster‑recovery.
Focus on core business – IT staff can concentrate on strategic projects.

2.2.6 Disadvantages / Risks

Dependence on Internet connectivity.
Security and privacy concerns (data stored off‑site).
Reduced control over underlying infrastructure.
Vendor lock‑in and data‑portability issues.
Variable performance due to multi‑tenant resource sharing.

2.2.7 Relationship to the TCP/IP Stack

Cloud services sit on top of the Internet layer of the TCP/IP model. Typical data flow:

Application layer – SaaS/PaaS/IaaS APIs (e.g., REST, SOAP).
Transport layer – TCP for reliable delivery, UDP for low‑latency streams.
Internet layer – IP routing between client device and provider’s data centre.
Link layer – Ethernet, Wi‑Fi, or other physical media connecting the end‑user to the ISP.

2.2.8 Example Scenario – University Virtual Lab (IaaS)

Spin up virtual machines pre‑loaded with specialised software for a programming course.
Scale the number of instances during exam periods; shut them down afterwards.
Pay only for the compute‑hours actually used, reducing departmental costs.

2.2.9 Simple Cost‑Estimation Formula

For a pay‑as‑you‑go model the monthly cost can be approximated by:

$$\text{Cost}_{\text{month}} = \displaystyle\sum_{i=1}^{n}\bigl(\text{Rate}_i \times \text{Usage}_i\bigr)$$

where n = number of resource types (compute, storage, bandwidth, etc.), Rate_i = price per unit, and Usage_i = quantity consumed in the month.

3 Hardware

3.1 Core Components

CPU (Central Processing Unit) – executes instructions; contains the Control Unit (CU), Arithmetic‑Logic Unit (ALU), and registers.
Memory hierarchy
- Registers – fastest, located inside the CPU.
- Cache (L1, L2, L3) – small, high‑speed memory close to the CPU.
- Primary memory – RAM (volatile) for active data.
- Secondary storage – HDD, SSD, optical media (non‑volatile).
Input/Output (I/O) devices – keyboards, mice, displays, printers, sensors.
Motherboard – connects CPU, memory, and peripherals via buses (e.g., PCIe, USB).

3.2 Embedded Systems

Special‑purpose computers integrated into devices (e.g., microwaves, automotive ECUs).
Typically use microcontrollers (CPU + memory + I/O on a single chip).
Programmed in low‑level languages (C, assembly) for real‑time performance.

3.3 Logic Gates & Boolean Algebra

Basic gates: AND, OR, NOT, NAND, NOR, XOR, XNOR.
Truth tables define output for each possible input combination.
Boolean expressions can be simplified using identities (e.g., De Morgan’s laws) to design efficient circuits.

4 Processor Fundamentals

4.1 Von Neumann Architecture

Single shared memory for instructions and data.
Program Counter (PC) points to the next instruction.
Fetch‑Decode‑Execute cycle repeats for each instruction.

4.2 Instruction Set & Assembly Language

Instructions are binary opcodes that the CPU recognises.
Typical categories: data movement (LOAD, STORE), arithmetic (ADD, SUB), logic (AND, OR), control flow (JUMP, BRANCH).

Simple assembly example (x86‑like):

            MOV AX, 5      ; load constant 5 into register AX
            ADD AX, 3      ; AX = AX + 3  → 8
            MOV [1000h], AX ; store result at memory address 1000h

4.3 Interrupts & Multitasking

Interrupt – external or internal signal that temporarily halts the current instruction stream, allowing the CPU to service a higher‑priority task.
Operating systems use interrupts to implement pre‑emptive multitasking (time‑slicing).

4.4 Parallel Processing (A‑Level Extension)

Multi‑core CPUs – multiple processing cores on a single die, each capable of executing its own instruction stream.
SIMD (Single Instruction, Multiple Data) – same operation applied to many data elements simultaneously (e.g., vector instructions).
Programming models: threads, OpenMP, GPU kernels (CUDA/OpenCL).

5 System Software

5.1 Operating System (OS) Functions

Process management – creation, scheduling, termination.
Memory management – allocation, paging, virtual memory.
File system – hierarchical storage, permissions.
Device drivers – abstract hardware for applications.
Security – authentication, access control, auditing.

5.2 Language Translators

Assembler – converts assembly language to machine code.
Compiler – translates high‑level source code to object code (often via an intermediate representation).
Interpreter – executes source code line‑by‑line; no separate executable is produced.
Hybrid approaches (e.g., Java) compile to bytecode, then interpret/just‑in‑time compile on the JVM.

5.3 Integrated Development Environments (IDEs)

Code editor with syntax highlighting.
Build tools (compilation, linking).
Debugger – set breakpoints, inspect variables, step through code.
Version‑control integration (Git, SVN).

6 Security, Privacy & Data Integrity

6.1 Core Principles (CIA Triad)

Confidentiality – prevent unauthorised access (encryption, access controls).
Integrity – ensure data is accurate and unaltered (hashes, checksums, digital signatures).
Availability – ensure services are accessible when needed (redundancy, DDoS mitigation).

6.2 Cryptography Basics

Symmetric encryption – same key for encryption/decryption (e.g., AES).
Asymmetric encryption – public/private key pair (e.g., RSA, ECC); used for key exchange and digital signatures.
Hash functions – produce a fixed‑size digest (e.g., SHA‑256); ideal for integrity checks.

6.3 Authentication & Authorisation

Something you know (password/PIN), have (smart card, token), or are (biometrics).
Role‑Based Access Control (RBAC) – permissions assigned to roles rather than individuals.

6.4 Common Threats

Malware – viruses, worms, ransomware.
Phishing – social engineering to obtain credentials.
Man‑in‑the‑middle (MITM) – intercepting communications.
Denial‑of‑Service (DoS/DDoS) – overwhelming a service.

6.5 Mitigation Strategies

Firewalls – packet filtering based on rules.
Intrusion Detection/Prevention Systems (IDS/IPS).
Regular patching and updates.
Backup & disaster‑recovery planning.

6.6 Ethical & Legal Considerations (A‑Level Extension)

Data protection regulations (GDPR, Data Protection Act).
Intellectual property – copyrights, patents, licences (GPL, MIT, proprietary).
Professional codes of conduct (e.g., BCS Code of Conduct).
AI ethics – bias, transparency, accountability.

7 Databases

7.1 Relational Model

Data stored in tables (relations) consisting of rows (records) and columns (attributes).
Primary key – uniquely identifies each row.
Foreign key – establishes a relationship between tables.

7.2 Normalisation

Form	Goal	Key Requirement
1NF	Eliminate repeating groups	Atomic (indivisible) attribute values.
2NF	Remove partial dependency	Every non‑key attribute fully depends on the whole primary key.
3NF	Remove transitive dependency	No non‑key attribute depends on another non‑key attribute.

7.3 Basic SQL Statements

-- Create a table
CREATE TABLE Students (
    StudentID INT PRIMARY KEY,
    Name VARCHAR(50),
    Course VARCHAR(30)
);

-- Insert data
INSERT INTO Students VALUES (1, 'Alice', 'Computer Science');

-- Retrieve data
SELECT Name, Course FROM Students WHERE StudentID = 1;

-- Update data
UPDATE Students SET Course = 'Mathematics' WHERE StudentID = 1;

-- Delete a record
DELETE FROM Students WHERE StudentID = 1;

7.4 Transactions & ACID Properties

Atomicity – all steps succeed or none do.
Consistency – database moves from one valid state to another.
Isolation – concurrent transactions do not interfere.
Durability – once committed, changes survive crashes.

7.5 NoSQL Overview (A‑Level Extension)

Key‑Value stores (e.g., Redis), Document databases (MongoDB), Column families (Cassandra), Graph databases (Neo4j).
Trade‑off: flexible schema & horizontal scalability vs. weaker ACID guarantees.

8 Algorithms & Problem Solving

8.1 Algorithm Design Techniques

Sequential – step‑by‑step execution.
Selection – if‑else, switch statements.
Iteration – loops (for, while, do‑while).
Recursion – function calls itself with a simpler input.
Divide‑and‑Conquer – split problem, solve sub‑problems, combine results (e.g., mergesort).

8.2 Pseudocode Conventions

FOR i FROM 1 TO n DO
    IF array[i] > max THEN
        max ← array[i]
    END IF
END FOR

8.3 Complexity Analysis

Time complexity – Big‑O notation (O(1), O(log n), O(n), O(n log n), O(n²), …).
Space complexity – amount of additional memory required.
Best, worst, and average‑case analysis.

8.4 Common Algorithms (A‑Level Extension)

Algorithm	Purpose	Complexity
Binary Search	Find element in sorted list	O(log n)
Mergesort	Stable sorting	O(n log n)
QuickSort	In‑place sorting	Average O(n log n), worst O(n²)
Dijkstra’s algorithm	Shortest path in weighted graph	O((V+E) log V)
Dynamic Programming (e.g., Fibonacci)	Optimal substructure, overlapping sub‑problems	O(n)

9 Data Types & Structures

9.1 Primitive Data Types

Integer, Float/Double, Boolean, Character, String.
Range and precision depend on language and word size (e.g., 32‑bit int).

9.2 Composite Data Structures

Arrays – fixed‑size, indexed collection of same‑type elements.
Records / Structures – group of heterogeneous fields (e.g., struct in C).
Lists – dynamic, can grow/shrink (linked list, array‑list).
Stacks – LIFO (push, pop).
Queues – FIFO (enqueue, dequeue); circular queue for fixed size.
Trees – hierarchical, binary tree, BST, AVL, heap.
Graphs – nodes (vertices) and edges; directed/undirected, weighted/unweighted.

9.3 Operations & Use‑Cases

Structure	Typical Operations	Typical Application
Array	Indexing, iteration	Static lookup tables
Linked List	Insertion/deletion at any position	Implementing queues, adjacency lists
Stack	Push, pop, peek	Expression evaluation, back‑tracking
Queue	Enqueue, dequeue	Print spooling, breadth‑first search
Binary Search Tree	Insert, delete, search (average O(log n))	Ordered data storage
Heap	Insert, extract‑max/min	Priority queues, heap sort

10 Programming

10.1 Structured Programming Concepts

Sequence, selection, iteration, sub‑routines (functions/procedures).
Modular design – divide program into reusable modules.
Top‑down design and flowcharts.

10.2 Example in Python (covers variables, control structures, functions)

def factorial(n):
    """Return n! using recursion."""
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

# Main program
num = int(input("Enter a number: "))
print(f"{num}! = {factorial(num)}")

10.3 Object‑Oriented Programming (A‑Level Extension)

Class – blueprint for objects; defines attributes (data) and methods (behaviour).
Encapsulation – hide internal state, expose public interface.
Inheritance – subclass derives properties from a superclass.
Polymorphism – same method name behaves differently for different classes.

Python example:

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

10.4 Development Methodologies

Waterfall – linear phases: requirements, design, implementation, testing, maintenance.
Agile (Scrum, Kanban) – iterative, incremental delivery, frequent stakeholder feedback.
Importance of version control (Git) and documentation.

11 Advanced Topics (A‑Level Extensions)

11.1 Artificial Intelligence & Machine Learning

Search algorithms – BFS, DFS, A*.
Knowledge representation – rules, semantic networks.
Machine learning basics – supervised learning (linear regression, decision trees), training vs. testing sets.
Ethical considerations – bias, transparency, impact on employment.

11.2 Advanced Security

Public Key Infrastructure (PKI) and certificate authorities.
Zero‑trust architecture – verify every access request.
Secure coding practices – input validation, parameterised queries (prevent SQL injection).
Blockchain fundamentals – distributed ledger, consensus mechanisms.

11.3 Parallel & Distributed Computing

Shared‑memory vs. message‑passing models.
MPI (Message Passing Interface) basics.
MapReduce paradigm – map, shuffle, reduce (e.g., Hadoop).
GPU computing – massive data‑parallelism for graphics and AI.

11.4 Emerging Programming Paradigms

Functional programming – pure functions, immutability (e.g., Haskell, Lisp).
Reactive programming – streams, event‑driven architectures.
Domain‑Specific Languages (DSLs) – tailored syntax for particular

Show understanding of cloud computing

1 Information Representation