IB Diploma Programme Computer Science Higher Level

A1 — Computer Fundamentals

• Recall and apply binary and hexadecimal number systems by converting between bases, representing signed integers using two's complement, and explaining why computers use binary at the hardware level
• Explain how text, images, audio, and video are encoded as binary data by describing character sets (ASCII/Unicode), pixel colour depth, sampling rate, and the trade-offs introduced by lossy versus lossless compression
• Apply Boolean logic and truth tables to design simple combinational circuits using AND, OR, NOT, NAND, NOR, and XOR gates, and verify gate output for all possible input combinations
• Describe the roles of the ALU, control unit, instruction register, program counter, MAR, MDR, and accumulator, and trace the steps of the fetch-decode-execute cycle showing data movement between registers and memory
• Distinguish RAM, ROM, cache (L1/L2/L3), and virtual memory by speed, capacity, volatility, and cost, and explain how cache hits and misses affect CPU throughput in the fetch-decode-execute cycle
• Evaluate CPU pipelining and multi-core architecture by explaining how instruction-level parallelism is achieved across fetch, decode, execute, and writeback stages, describing hazard types, and analysing throughput versus latency trade-offs (HL)
• Compare CPU and GPU design philosophies by contrasting core count, clock speed, and memory bandwidth architectures, and justify when GPU parallel processing is preferable to CPU sequential execution for data-intensive workloads (HL)
• Compare internal and external secondary storage technologies — HDD, SSD, optical, and cloud — by evaluating access speed, durability, capacity, and cost to recommend appropriate storage for given organisational use cases
• Distinguish SaaS, PaaS, and IaaS cloud service models by describing the provider versus customer responsibility boundary and selecting the appropriate model for given application deployment and management scenarios

A2 — Networks

• Describe wired and wireless network topologies — bus, star, ring, mesh, and hybrid — and analyse reliability, scalability, and cost trade-offs to recommend an appropriate topology for a given organisational context
• Explain the functions of gateways, firewalls, modems, routers, switches, and access points, distinguishing layer 2 switching from layer 3 routing and the role each device plays in packet forwarding
• Describe the four-layer TCP/IP model — network interface, internet, transport, and application — explaining the role and key protocols at each layer and how encapsulation/decapsulation achieves end-to-end reliable delivery (HL)
• Compare TCP and UDP transport protocols by evaluating connection setup, reliability mechanisms, flow control, and suitability for streaming versus reliable transfer; and explain HTTP, HTTPS, and DHCP at the application layer
• Describe the specific functions of DNS, DHCP, file, mail, proxy, and web servers, and explain the request-response sequence each server type follows to fulfil a client request within a TCP/IP network (HL)
• Evaluate cybersecurity threats — malware, phishing, man-in-the-middle, and denial-of-service attacks — and justify appropriate countermeasures including symmetric/asymmetric encryption, TLS, VPNs, firewalls, and multi-factor authentication

A3 — Databases

• Explain the relational database model by defining primary keys, foreign keys, and composite keys, describing one-to-one, one-to-many, and many-to-many relationships, and constructing entity-relationship diagrams for a given domain
• Apply normalisation to relational schemas by identifying first, second, and third normal form violations, restructuring tables to eliminate redundancy and update/insert/delete anomalies with documented justification
• Construct SQL queries using SELECT, INSERT, UPDATE, and DELETE statements with WHERE, JOIN (INNER/LEFT/RIGHT), GROUP BY, and ORDER BY clauses to retrieve and manipulate data across multiple related tables
• Evaluate database transactions using ACID properties — atomicity, consistency, isolation, durability — and construct SQL views to abstract complex joins into reusable named queries for application consumers (HL)
• Compare relational and NoSQL database paradigms — document, key-value, column-family, and graph stores — by evaluating schema flexibility, horizontal scalability, CAP theorem trade-offs, and appropriate selection criteria (HL)

A4 — Machine Learning

• Explain the machine learning paradigm by distinguishing supervised, unsupervised, and reinforcement learning approaches and describing how labelled versus unlabelled training data determines the applicable algorithm family
• Apply data preprocessing and feature selection techniques — handling missing values, normalisation, one-hot encoding of categorical variables, and correlation-based feature elimination — to prepare a dataset for model training (HL)
• Analyse artificial neural network structure by explaining the roles of input, hidden, and output layers, activation functions, forward propagation, and how backpropagation with gradient descent iteratively adjusts weights to minimise loss (HL)
• Evaluate deep learning architectures — CNNs for image recognition and RNNs for sequential data — by explaining their structural adaptations (convolutional layers, pooling, recurrent connections) and selecting the appropriate architecture for a given task (HL)
• Evaluate genetic algorithm components — population initialisation, fitness function, selection, crossover, mutation, and termination criteria — by applying the algorithm to an optimisation problem and analysing convergence behaviour (HL)
• Explain reinforcement learning by describing the agent-environment interaction loop, reward signals, policy, value function, and the exploration-versus-exploitation trade-off, identifying real-world domains where RL outperforms supervised approaches (HL)
• Strategise responsible ML deployment by critically evaluating sources of algorithmic bias in training data and model outputs, assessing fairness metrics, transparency obligations, and societal impacts of automated decision-making systems

B1 — Computational Thinking

• Apply abstraction as a computational thinking technique by identifying and suppressing irrelevant detail to model a real-world problem as a computational entity with precisely defined inputs, outputs, and state
• Apply problem decomposition by breaking a complex computing problem into independently solvable sub-problems and representing the decomposition structure clearly before selecting implementation strategies
• Construct algorithmic solutions in pseudocode using sequence, selection, and iteration constructs that correctly specify a solution at a level of detail sufficient for direct translation to a target language
• Apply pattern recognition to identify recurring computational structures — sorting, searching, recursion, divide-and-conquer — across novel problems and select the appropriate algorithmic template based on problem characteristics
• Analyse algorithm efficiency by determining best, average, and worst-case time complexity using Big-O notation for O(1), O(log n), O(n), O(n log n), and O(n²) algorithms, and justify selection based on input-size constraints

B2 — Programming

• Recall and apply primitive data types — integer, float, boolean, character, and string — by declaring variables, assigning values, and explaining type implications for memory allocation and arithmetic operations in Java or Python
• Construct programs using selection (if/else, switch/match) and iteration (for, while, do-while) constructs to implement decision logic and loop patterns correctly in either Java or Python
• Construct and manipulate one-dimensional and two-dimensional arrays (Java) or lists (Python) by implementing traversal, insertion, deletion, and linear search operations across indexed data structures
• Apply string manipulation operations — concatenation, substring extraction, length measurement, splitting, and pattern searching — to process and validate textual data in programs written in Java or Python
• Construct reusable methods and functions with defined parameter lists and return types, applying local and global scope rules and tracing how the call stack manages activation records during nested function execution
• Construct recursive solutions for factorial, Fibonacci, and binary search by defining the base case and recursive case, tracing the call stack depth, and comparing recursive versus iterative implementations on time and space efficiency
• Construct and trace bubble sort, selection sort, and insertion sort, comparing their O(n²) worst-case complexities and explaining the conditions under which insertion sort outperforms the other two on partially sorted data
• Construct and compare linear search (O(n)) and binary search (O(log n)) by implementing both in code, tracing execution on ordered and unordered datasets, and evaluating the precondition requirements of binary search
• Construct programs that perform sequential file reading and writing using text files, handling IOExceptions and file-not-found errors appropriately in Java or Python within a try-catch or try-except block
• Evaluate the translation process from high-level source code to machine instructions by contrasting compilers and interpreters, and describing the roles of lexical analysis, parsing, semantic analysis, and code generation phases (HL)

B3 — Object-Oriented Programming

• Construct a class in Java or Python by defining private instance variables, a parameterised constructor, getter and setter methods, and at least two domain-specific behaviours, then instantiate objects and trace method calls to verify state transitions
• Apply encapsulation by declaring instance variables as private and exposing controlled access through public accessor and mutator methods, explaining how encapsulation protects invariants and isolates implementation from interface
• Construct class hierarchies using inheritance in Java or Python by extending parent classes, invoking super constructors, and explaining how private, protected, and public access modifiers control member visibility across parent-child relationships (HL)
• Construct programs demonstrating runtime polymorphism through method overriding and static polymorphism through method overloading, and analyse how polymorphism enables open-closed design without modifying existing class hierarchies (HL)
• Evaluate abstraction in OOP by designing abstract classes and interfaces in Java (or abstract base classes in Python) to define implementation contracts, and justify selection between abstract classes and interfaces for extensible system design (HL)
• Apply composition and aggregation relationships between classes by modelling has-a relationships in UML class diagrams and implementing them in code, contrasting the lifecycle dependencies of composition versus aggregation (HL)

B4 — Abstract Data Types (HL Only)

• Explain the abstract data type concept by distinguishing the logical interface — operations and invariants — from the concrete implementation, and justify why ADTs support modular program design by decoupling callers from data structure internals
• Construct stack (LIFO) and queue (FIFO) ADTs using arrays or linked nodes, implement push/pop and enqueue/dequeue operations with overflow/underflow handling, and apply each to a concrete problem such as expression evaluation or BFS
• Construct singly linked, doubly linked, and circular linked lists by implementing node insertion at head, tail, and arbitrary position; deletion; traversal; and search operations in Java or Python with pointer/reference management
• Construct a binary search tree by implementing insert, search, and delete operations, performing in-order, pre-order, and post-order traversals, and explaining the BST ordering property that yields O(log n) average-case search on balanced trees
• Construct a set ADT by implementing membership test, element insertion, removal, and subset/superset operations, and apply sets to solve problems requiring uniqueness guarantees such as duplicate detection or Venn-diagram modelling
• Evaluate hash table design by explaining hashing functions, collision resolution strategies (chaining and linear/quadratic open addressing), and how load factor determines when resizing is necessary to maintain O(1) average search performance
• Strategise ADT selection for a given computational problem by comparing stacks, queues, linked lists, binary search trees, sets, and hash tables across time complexity, space complexity, ordering requirements, and implementation overhead

Define an IA computational solution problem by specifying client requirements, system scope, measurable success criteria, and constraints in a structured problem-specification document following IB IA guidelines

Construct a comprehensive design plan for the IA computational solution including UML class diagrams, data flow descriptions, UI wireframes, and algorithm pseudocode specifications prior to any implementation

Synthesise a working IA computational solution in Java or Python that applies OOP design with inheritance and encapsulation, appropriate data structures, file or database persistence, and a functional user interface meeting client requirements within 35 hours

Strategise IA solution quality by designing a testing plan with normal, boundary, and erroneous test cases; documenting test results against stated success criteria; producing a video demonstration; and critically reflecting on limitations and improvements