Computer Science

Data Types

User-Defined Types

Variable Declaration

Constant Declaration

Assignment Statements

Selection Statements

Iteration Statements

Definite Iteration

Indefinite Iteration

Nested Selection

Nested Iteration

Identifier Naming

Arithmetic Operators

Integer Division and Mod

Rounding and Truncation

Relational Operators

Boolean Operators

Constants vs Variables

Named Constants

String Length

String Position

Substrings

String Concatenation

Character ↔ Code

String Type Conversions

Random Number Generation

Exception Handling

Subroutines Overview

Procedures vs Functions

Subroutine Parameters

Returning Values

Local Variables

Global Variables

Stack Frames

Recursion

Procedural Paradigm

Structured Programming

Hierarchy Charts

Object-Oriented Concepts

Classes and Objects

Encapsulation

Inheritance

Polymorphism and Overriding

Aggregation vs Composition

OOP Access Modifiers

Abstract / Virtual / Static Methods

UML Class Diagrams

OOP Design Principles

Data Structures Overview

1D Arrays

2D Arrays

Multidimensional Arrays

Fields and Records

Text Files

Binary Files

Abstract Data Types Overview

Static vs Dynamic Structures

Queues Overview

Linear Queues

Circular Queues

Priority Queues

Queue Operations

Stacks Overview

Stack Operations

Graphs Overview

Weighted Graphs

Directed vs Undirected Graphs

Adjacency Matrices

Adjacency Lists

Trees Overview

Rooted Trees

Binary Trees

Binary Search Trees

Hash Tables Overview

Hash Functions

Collisions and Rehashing

Dictionaries Overview

Key–Value Pairs

Information Retrieval Dictionaries

Vectors as Lists

Vectors as Functions

Vector Notation

Vector Addition

Scalar Multiplication

Dot Product

Dot Product Applications

Breadth-First Search (BFS)

Depth-First Search (DFS)

BFS vs DFS Use Cases

Pre-Order Traversal

In-Order Traversal

Post-Order Traversal

Tree Traversal Use Cases

Infix to RPN Conversion

RPN to Infix Conversion

RPN Evaluation Context

Linear Search

Binary Search

Binary Tree Search

Bubble Sort

Merge Sort

Dijkstra’s Algorithm

Shortest Path Applications

Logic Problem Solving

Algorithm Definition

Pseudocode Constructs

Hand Tracing Algorithms

Pseudocode to Code

Representational Abstraction

Generalisation and Categorisation

Information Hiding

Procedural Abstraction

Functional Abstraction

Data Abstraction

Problem Reduction

Decomposition

Composition

Automation (Models to Code)

FSMs Without Output

FSMs With Output (Mealy)

Set Notation

Set Comprehension

Empty Set

Finite vs Infinite Sets

Countably Infinite Sets

Set Cardinality

Cartesian Product

Subsets and Proper Subsets

Set Operations (∪, ∩, )

Regular Expressions Basics

Regex Metacharacters (* + ? |)

Regex Grouping ( )

Regex ↔ FSM Equivalence

Regular Languages

Backus–Naur Form (BNF)

Syntax Diagrams

Production Rules

Regular vs Context-Free Languages

Comparing Algorithm Efficiency

Time vs Space Complexity

Big-O Notation

Constant / Log / Linear

Polynomial vs Exponential

Deriving Big-O

Limits of Computation

Tractable vs Intractable Problems

Heuristics for Intractable Problems

Computable vs Non-Computable Problems

Halting Problem

Turing Machine Structure

Transition Functions

State Transition Diagrams

Hand-Tracing Turing Machines

Universal Turing Machine Significance

Natural Numbers

Integers

Rational Numbers

Irrational Numbers

Real Numbers

Ordinal Numbers

Counting vs Measurement

Decimal (Base 10)

Binary (Base 2)

Hexadecimal (Base 16)

Base Conversion

Hex as Binary Shorthand

Bits and Bytes

Values Representable with n Bits

Binary Prefixes (KiB, MiB, GiB, TiB)

Decimal Prefixes (kB, MB, GB, TB)

Unsigned Binary

Unsigned Binary Range

Binary Addition

Binary Multiplication

Two’s Complement

Two’s Complement Range

Two’s Complement Subtraction

Fixed-Point Binary

Fixed-Point Conversions

Digit Character Codes vs Binary

ASCII

Unicode

Parity Bits

Majority Voting

Checksums

Check Digits

Analogue vs Digital Data

Analogue vs Digital Signals

ADC Principles

DAC Principles

Bitmapped Graphics

Bitmap Resolution

Bitmap Colour Depth

Bitmap File Size Calculations

Bitmap Metadata

Vector Graphics

Vector Graphic Primitives

Vector vs Bitmap Comparison

Sound Sampling Rate

Sample Resolution

Nyquist Theorem

Sound File Size Calculations

MIDI Purpose

MIDI Event Messages

MIDI Advantages

Lossless vs Lossy Compression

Run-Length Encoding (RLE)

Dictionary-Based Compression

Encryption Terminology

Caesar Cipher

Vernam Cipher (One-Time Pad)

Perfect vs Computational Security

Hardware vs Software

System Software

Application Software

Operating Systems Functions

Utility Programs

Libraries

Translators Overview

OS Resource Management

Low-Level Languages

Machine Code

Assembly Language

High-Level Languages

Imperative Languages

Assembler Role

Compiler Role

Interpreter Role

Compilation vs Interpretation

Bytecode / Intermediate Code

Source vs Object Code

NOT / AND / OR / XOR Gates

NAND / NOR Gates

Logic Gate Truth Tables

Logic Gate Circuits

Boolean Expressions from Circuits

Circuits from Boolean Expressions

Half-Adder

Full-Adder

D-Type Flip-Flop

Boolean Identities

De Morgan’s Laws

Boolean Simplification

Processor, Memory, Buses

Address Bus

Data Bus

Control Bus

I/O Controllers

Bus Communication

Von Neumann Architecture

Harvard Architecture

Embedded Systems Context

Addressable Memory

Stored Program Concept

ALU

Control Unit

Clock

General-Purpose Registers

Program Counter (PC)

Current Instruction Register (CIR)

Memory Address Register (MAR)

Memory Buffer Register (MBR)

Status Register

Fetch–Decode–Execute Cycle

Processor Instruction Set

Opcode and Operands

Immediate Addressing

Direct Addressing

Assembly Mnemonics

LOAD / STORE

ADD / SUBTRACT

Branching

Compare

Bitwise Operators

Shifts

HALT

Performance: Cores

Performance: Cache

Performance: Clock Speed

Performance: Word Length

Performance: Bus Widths

Input Devices (Barcode, RFID)

Output Devices (Laser, Camera)

Secondary Storage Purpose

Hard Disks

Optical Disks

Solid State Drives (SSD)

Storage Speed vs Capacity

Moral Issues

Ethical Issues

Social Impacts

Legal Issues

Cultural Impacts

Opportunities of Computing

Risks of Computing

Monitoring Behaviour

Personal Data Collection

Data Analysis at Scale

Publishing and Dissemination

Responsibilities of Developers

Embedded Values in Software

Scale and Harm Potential

Legislative Challenges

Serial Transmission

Parallel Transmission

Synchronous Transmission

Asynchronous Transmission

Start and Stop Bits

Baud Rate

Bit Rate

Bandwidth

Latency

Protocols

Physical Star Topology

Logical Bus Topology

Peer-to-Peer Networking

Client–Server Networking

WiFi Purpose

Wireless Adapters

Wireless Access Points

Wireless Security (WPA/WPA2)

SSID

MAC Allow Lists

CSMA/CA

RTS/CTS

Internet Structure

Packet Switching

Routers

Gateways

Packet Components

Routing Across the Internet

URLs

FQDNs

Domain Names

IP Addresses

Domain Name System (DNS)

Internet Registries

Firewalls (Filtering/Proxy/Stateful)

Symmetric Encryption

Asymmetric Encryption

Key Exchange

Digital Certificates

Digital Signatures

Worms, Trojans, Viruses

Software Vulnerabilities

Mitigations (Code Quality/Monitoring)

TCP/IP Layers

Sockets

MAC Addresses

Well-Known vs Client Ports

FTP

HTTP

HTTPS

POP3

SMTP

SSH

FTP Anonymous vs Authenticated

SSH Remote Management

Email Server Role

Web Server Role

Web Browser Role

IP Network vs Host Parts

Subnet Masks

IPv4 vs IPv6

Public vs Private IPs

DHCP

Network Address Translation (NAT)

Port Forwarding

Client–Server Request/Response

WebSockets

Web CRUD Principles

REST Principles

CRUD ↔ HTTP Mapping

REST ↔ SQL Mapping

REST APIs

JSON Data Exchange

XML Data Exchange

JSON vs XML Comparison

Thin Clients

Thick Clients

Data Requirements to Data Model

Entities and Attributes

Entity Identifiers

Entity Relationship Diagrams (ERD)

Relational Database Concept

Attributes

Primary Keys

Composite Keys

Foreign Keys

Normalisation Purpose

Third Normal Form (3NF)

SQL SELECT

SQL INSERT

SQL UPDATE

SQL DELETE

SQL Table Definition (DDL)

Client–Server Databases

Concurrent Access Issues

Record Locking

Serialisation

Timestamp Ordering

Commitment Ordering

Big Data Definition

Volume

Velocity

Variety

Structured vs Unstructured Data

Relational Database Limitations

Pattern Discovery and ML Context

Distributed Processing Need

Functional Programming for Distribution

Immutability

Statelessness

Higher-Order Functions

Fact-Based Data Model

Graph Schema

Nodes, Edges, Properties

Function Types (A → B)

Domain and Co-Domain

Functions as First-Class Objects

Function Application

Partial Application

Currying Notation

Function Composition

Functional Languages Examples

Higher-Order Functions

Map

Filter

Reduce / Fold

Lists as Head and Tail

Empty Lists

Head Operation

Tail Operation

Empty Test

List Length

Prepend

Append

Problem Definition

Requirements Gathering

Data Modelling

Solution Design

Modular Design

Algorithm Design

UI Design

Iterative / Agile Design

Implementation Planning

Debugging Practice

Testing with Normal Data

Boundary Testing

Erroneous Data Testing

Acceptance Testing

User Feedback Evidence

Evaluation Criteria

Project Purpose

Problem vs Investigation Choice

Feasibility of Technical Challenge

Project Planning

Analysis Evidence

Design Evidence

Technical Solution Evidence

Solution Completeness

Techniques and Complexity

Coding Style

Testing Evidence

Evaluation Evidence

Documentation Conciseness

Marking Focus Areas