Show understanding of cloud computing

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)

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

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)

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

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

2.2.4 Deployment Models

1. Public Cloud – owned/operated by a third‑party provider; resources shared among many organisations.
2. Private Cloud – dedicated infrastructure for a single organisation (on‑premises or hosted).
3. Hybrid Cloud – integration of public and private clouds; workloads can move between them.
4. 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:

1. Application layer – SaaS/PaaS/IaaS APIs (e.g., REST, SOAP).
2. Transport layer – TCP for reliable delivery, UDP for low‑latency streams.
3. Internet layer – IP routing between client device and provider’s data centre.
4. 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

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)

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

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