IB Diploma Programme Computer Science — SL & HL
All the IB DP Computer Science core and HL extension content in one sheet — Topics 1–7, Big-O complexity, data representation, OOP option, network protocols, and exam technique for Papers 1, 2, 3 and the IA.
Our formula sheets are free to download — save this one as PDF for offline revision.
Aligned with the latest 2026 syllabus and board specifications. This sheet is prepared to match your exam board’s official specifications for the 2026 exam series.
IB Computer Science blends conceptual theory with practical computational thinking. This sheet brings together every topic, every key formula (file size, Big-O, binary), and the structure for Paper 1, Paper 2, the HL Paper 3 case study, and the IA — fully aligned to the SL and HL syllabus.
Topics 1–4 core plus HL Topics 5–7 extension content
Big-O complexity for searches and sorts at a glance
Data representation: binary, hex, two's complement, file size formulas
OOP option overview, Paper 3 case study technique, and IA structure
How systems are planned, designed, deployed, and replaced.
Analysis → Design → Implementation → Testing → Maintenance → Removal Planning
Feasibility study, scope, requirements gathering (interviews, observation, questionnaires) Design
System flowcharts, data flow diagrams, prototyping (rapid, evolutionary, throwaway) Implementation
Direct/big-bang, parallel, phased, pilot conversion strategies Resistance to change | Training (formal, on-the-job, online) | User documentation | Removing legacy systems: data migration, hardware/software compatibility, parallel running during cutover Compatibility | Interoperability | APIs and middleware | Testing across environments (unit, integration, system, acceptance) Inside the box — CPU, memory, and the fetch-decode-execute cycle.
ALU
Arithmetic Logic Unit — performs arithmetic and logical operations Control Unit
Directs operation of the processor; interprets instructions Registers
MAR (Memory Address Register), MDR (Memory Data Register), PC (Program Counter), CIR (Current Instruction Register), Accumulator FETCH: PC → MAR → memory → MDR → CIR; PC incremented | DECODE: Control unit interprets instruction in CIR | EXECUTE: ALU performs operation; result stored Primary memory
RAM (volatile, read/write) | ROM (non-volatile, read-only — stores boot/firmware) Cache hierarchy
L1 (fastest, smallest, on-chip) → L2 → L3 (larger, slower) — reduce average memory access time Secondary storage
HDD (magnetic), SSD (flash), optical, cloud — non-volatile, larger, slower Layered architecture, protocols, and security.
PAN (personal, ~10m, e.g. Bluetooth) | LAN (local, building/campus) | WAN (wide-area, e.g. internet) | MAN, SAN, VPN Topologies
Bus | Star | Ring | Mesh | Tree/Hybrid 7. Application | 6. Presentation | 5. Session | 4. Transport | 3. Network | 2. Data Link | 1. Physical Mnemonic: 'All People Seem To Need Data Processing' (top-down).
Transport
TCP (reliable, connection-oriented) | UDP (faster, connectionless) Application
HTTP/HTTPS (web) | FTP (file transfer) | SMTP (email send) | POP3/IMAP (email retrieve) | DNS (name resolution) IPv4
32-bit address (e.g. 192.168.1.1) — ~4.3 billion addresses (exhausted) IPv6
128-bit address (8 groups of 4 hex digits) — vastly larger address space MAC address
48-bit physical hardware address, globally unique Packet switching
Data broken into packets, routed independently, reassembled at destination Encryption (symmetric e.g. AES; asymmetric e.g. RSA) | Authentication (passwords, 2FA, biometrics) | Firewalls (packet filtering, stateful inspection) | VPNs (encrypted tunnel) | SSL/TLS for HTTPS From abstraction to Big-O complexity.
Abstraction
Hide irrelevant detail, focus on essentials Decomposition
Break a complex problem into smaller sub-problems Pattern Recognition
Identify similarities to reuse known solutions Algorithm Design
Stepwise procedure → pseudocode → flowchart → code Linear Search
O(n) — works on unsorted data; check each element in turn Binary Search
O(log n) — REQUIRES sorted data; halve search space each step Bubble Sort
O(n²) average & worst — repeatedly swap adjacent out-of-order pairs Insertion Sort
O(n²) average & worst, O(n) best — build sorted portion one element at a time Selection Sort
O(n²) all cases — repeatedly select minimum and place at front Merge Sort
O(n log n) all cases — divide and conquer (uses extra memory) Quicksort
O(n log n) average, O(n²) worst — pivot-based partitioning loop FROM i = 0 TO n - 1 / end loop | loop WHILE condition / end loop | if … then … else … end if | INPUT / OUTPUT | algorithm method (parameters) Flowchart symbols
Oval = start/end | Parallelogram = input/output | Rectangle = process | Diamond = decision | Arrows = flow HL students study three additional topics on top of the SL core.
Stack
LIFO — push/pop/peek; used in function calls, undo operations Queue
FIFO — enqueue/dequeue; used in print spooling, BFS Linked List
Nodes with data + pointer to next; singly/doubly linked; dynamic size Binary Tree
Each node has at most two children. Binary Search Tree: left < parent < right BST Traversals
Pre-order (root → L → R) | In-order (L → root → R, gives sorted output) | Post-order (L → R → root) Recursion
Function calls itself; needs base case + recursive case (e.g. factorial, Fibonacci, tree traversal) Virtual memory
Use disk space as RAM extension — paging swaps pages between disk and RAM Threading
Multiple threads share process memory; concurrency vs parallelism Scheduling
FCFS | SJF (Shortest Job First) | Round Robin | Priority — minimise wait time / maximise throughput Embedded systems
Dedicated computer inside a larger device (washing machines, cars, medical equipment) Sensors & actuators
Sensors (temperature, light, pressure, motion) gather input | Actuators (motors, valves, LEDs) produce output Control loops
Open-loop (no feedback) vs Closed-loop (feedback adjusts output — e.g. thermostat using a PID controller) Java/Python pseudocode in IB style; OOP is one of four option choices.
Sequence | Selection (if/switch) | Iteration (for/while/do-while) | Subprograms (procedures, functions, methods) Parameter passing
By value (copy passed; original unchanged) | By reference (memory address passed; original can be modified) Scope
Local (inside subprogram) vs Global (entire program) — prefer local for encapsulation Available at SL and HL — HL studies it in greater depth.
Encapsulation
Bundle data + methods inside a class; restrict direct access via private fields and public getters/setters Inheritance
Subclass inherits attributes and methods from a superclass (extends); promotes reuse Polymorphism
Same method name behaves differently depending on object type (overriding, overloading) Abstraction
Expose essential features only; hide implementation detail (interfaces, abstract classes) UML Class Diagrams
Class name | Attributes (− private, + public, # protected) | Methods | Relationships: inheritance ▷, aggregation ◇, composition ◆, association — Option A: Databases (relational model, SQL, normalisation, ACID) | Option B: Modelling & Simulation (numerical methods, Monte Carlo) | Option C: Web Science (HTTP, search engines, web indexing, semantic web) | Option D: OOP (above) Numerical questions reward accurate base conversion and unit handling.
Binary → Denary
Sum of place values (128, 64, 32, 16, 8, 4, 2, 1) Denary → Binary
Repeated division by 2; read remainders bottom-up Binary → Hex
Group into nibbles (4 bits) from the right; convert each to 0–F Two's Complement (negative integers)
Invert bits, add 1. Range for n bits: −2^(n−1) to 2^(n−1) − 1 ASCII
7-bit (128 chars); extended ASCII 8-bit (256 chars) Unicode (UTF-8/16/32)
Variable/fixed width — supports >1 million code points across all writing systems Image
File size (bits) = Width × Height × Colour Depth | divide by 8 for bytes Sound
File size (bits) = Sampling Rate (Hz) × Duration (s) × Bit Depth × Channels | divide by 8 for bytes Units
1 byte = 8 bits | 1 KB = 1024 B | 1 MB = 1024 KB | 1 GB = 1024 MB (binary prefix) Operators
AND (∧) | OR (∨) | NOT (¬) | XOR (⊕) | NAND | NOR Identities
A AND 1 = A | A OR 0 = A | A AND A' = 0 | A OR A' = 1 | De Morgan's: ¬(A∧B) = ¬A ∨ ¬B Each paper assesses a different skill — match technique to assessment.
Short and structured questions on Topics 1–4 (and 5–7 for HL).
SL: 1h 30m, ~70 marks | HL: 2h 10m, ~100 marks | Section A: short structured | Section B: extended response (HL has additional questions on Topics 5–7) Use precise terminology — 'CPU', 'cache', 'O(log n)' etc. — not vague descriptions.
Tests the chosen option topic (e.g. OOP, Databases, Web Science, Modelling).
SL: 1h, ~45 marks | HL: 1h 20m, ~65 marks | Mix of short structured and extended-response questions on the chosen option An annually pre-released case study — typically a real-world application (AI, distributed computing, autonomous vehicles).
1h, 30 marks | Apply core + HL topics + outside research to scenario | Q1–3 short structured; Q4 extended evaluation/recommendation Read the case 4–6 weeks early; build a glossary of unfamiliar terms; rehearse applied answers.
A working computational solution to a real client's problem.
Required documents
(A) Cover page | (B) Stage A: Planning (consultation, success criteria, rationale, requirements) | (C) Stage B: Design (records of design, decomposition, algorithms, test plan) | (D) Stage C: Development (techniques used, screenshots, evidence of complexity) | (E) Stage D: Functionality & Extensibility — video screencast (max 6 min) | (F) Plan & Evaluation against success criteria | Crucial: the product file itself Worth 30% of the final grade at both SL and HL. Plan early — the development log builds throughout the year.
Boost your Cambridge exam confidence with these proven study strategies from our tutoring experts.
For every sort and search, walk through a small array on paper. Knowing steps cold is the fastest way to lock in Big-O intuition.
These appear in nearly every Paper 1. Memorise the formulas, watch units (bits vs bytes), and always show working.
Get the case as soon as it's released. Build a one-page glossary, identify topics it tests, and rehearse application — outside reading is rewarded.
Pick a real client, document every design decision, and prioritise complexity that demonstrates IB techniques (file I/O, OOP, search/sort, validation).
Quick answers about this free PDF and how to use it for exam revision and active recall.
Yes. This Tutopiya formula sheet is free to use and you can download it as a PDF from this page for offline revision. There is no payment or account required for the PDF download.
This page groups key Computer Science formulas in one place for revision. Master IB Diploma Programme Computer Science (SL & HL) with this 2026 formula sheet. Covers Topics 1–7, Big-O complexity, data representation, OOP, networks, abstract data structures, HL Paper 3, and the IA. Always cross-check with your official syllabus and past papers for your exam session.
No. In the exam you must follow only what your exam board allows in the hall—usually the official formula booklet or data sheet where provided. This page is a revision and teaching aid, not a replacement for board-issued materials.
It is written for students preparing for assessments at Post-Secondary in Computer Science, including classroom revision, homework support, and independent study. Teachers and tutors can also share it as a quick reference.
Work through past paper questions, quote the correct formula before substituting values, and check units and notation every time. Pair this sheet with timed practice and mark schemes so you see how examiners expect working to be set out.
Explore Tutopiya’s study tools, past paper finder, and revision checklists linked from our tools hub, or book a trial lesson with a subject specialist for personalised support alongside this formula reference.
Work through Big-O complexity, the OOP option, the HL Paper 3 case, and the IA with an experienced IB DP Computer Science tutor. We focus on precise terminology, applied algorithm design, and top-band exam technique.
Pair this formula sheet with past papers, revision checklists, and planners — all free on our study tools hub.
This formula sheet aligns with the IB Diploma Programme Computer Science syllabus (SL & HL) for first assessment 2026.
Always use precise IB terminology, show working in numerical questions, and apply algorithms with worked traces where required.