IB Computer Science

The CPU is the engine of every computer. In this unit you will see what is inside it, how the fetch-decode-execute cycle runs an instruction, and how memory is arranged from fast registers down to slower storage.

Everything a computer stores is binary. This unit covers binary and hexadecimal numbers, how integers and characters are encoded, and how logic gates and truth tables turn those bits into decisions.

Between your program and the hardware sit two vital layers. This unit covers what the operating system does, how it schedules work and handles interrupts, and how compilers and interpreters turn source code into machine code.

A network connects devices so they can share data and resources. In this unit you will learn the main types of network (LAN, WAN, PAN and VPN), the digital infrastructure that the internet is built on, and what the key hardware devices actually do. Get these building blocks solid and the rest of the topic follows.

Protocols are the agreed rules that let devices exchange data correctly. This unit covers the key transport and application protocols (TCP, UDP, HTTP, HTTPS and DHCP), how the four-layer TCP/IP model organises communication, how packet switching moves data across a network, and how the choice of transmission media affects performance. The TCP/IP model detail is AHL content.

Every device on a network needs an address so data can find it. This unit explains IPv4 and IPv6 addressing, the difference between public and private addresses, static versus dynamic assignment, how NAT stretches a limited supply of addresses, and how routers decide where packets go using static and dynamic routing. Static and dynamic routing is AHL content.

Databases store data in an organized way so it can be queried and analysed. This unit covers why we move from a single flat file to a relational database made of linked tables, the keys that create those links, and the relationships between entities.

Good database design plans the structure before any data is added. This unit covers the three schema levels, entity relationship diagrams (ERDs), the data types used in tables, and how to normalize a database to third normal form to remove anomalies.

SQL (structured query language) is used to build a database and to work with the data inside it. This unit covers the four SQL language families, how to query and join tables, and how databases stay reliable for many users at once using views and ACID transactions. Aggregate functions, views and transactions are Higher Level topics.

Computational thinking is the framework computer scientists use to examine problems whose solutions can be represented computationally. It rests on four fundamental concepts: abstraction, algorithmic design, decomposition and pattern recognition. This unit defines each one and shows how they work together across real computer science domains. (B1 is common to SL and HL, with no AHL-only material.)

Before solving a problem, a computer scientist writes a clear problem specification so they understand every part of the problem first. A specification may include a problem statement, constraints and limitations, objectives and goals, input specifications, output specifications and evaluation criteria. This unit covers all six components. (This is B1.1.1, common to SL and HL, with no AHL-only material.)

A flowchart depicts a process, its decisions and its flow of control, and it can represent the logic of a program so you can trace it. This unit covers the standard flowchart symbols and how to trace a flowchart to follow execution, track variable changes and work out the output. (This is B1.1.4, common to SL and HL, with no AHL-only material.)

Every program stores and works with data. This unit covers what a variable is, the data types you need to know for IB CS, the difference between local and global variables, and the operators you use to calculate, compare and combine values. All of it is core B2.1 material, required at both SL and HL, so there is no HL-only content here. Examples follow the book's Java and Python style.

Programs decide what to do and repeat work using control structures. This unit covers sequence (running instructions in the right order), selection (making decisions with if statements) and iteration (repeating code with while and for loops), including when to choose one loop over the other. This is core B2.3 material for both SL and HL, so there is no HL-only content here. Trace the code examples yourself to check the outputs.

As programs grow, you break them into reusable functions and store data in collections. This unit covers modularization, the parameters and return values of a function, local versus global scope, and collections: one-dimensional and two-dimensional lists, plus the difference between static and dynamic data structures. This is core B2.2 and B2.3 material for both SL and HL, so there is no HL-only content here.

Topic B3 is HL only (AHL). Object-oriented programming lets you model real-world things as objects that bundle their data and their behaviours together, instead of scattering them across many separate variables and lists. This unit covers the building blocks the book starts with: what a class is, the attributes, methods and constructor inside it, how you instantiate an object from a class, and the difference between static and non-static members.

Topic B3 is HL only (AHL). Object-oriented programming rests on four key principles: encapsulation, inheritance, polymorphism and abstraction. This unit explains each one in the book's terms, and covers the access modifiers (private, protected and public) that make encapsulation work and control what inherited subclasses can see.

Topic B3 is HL only (AHL). A UML (unified modelling language) class diagram is a universally recognised way to plan a class before you code it, and to show how classes relate to each other. This unit covers the three boxes of a class diagram, the notation for modifiers and static members, and the three relationships the book teaches: inheritance (is_a), aggregation (has_a) and composition (part_of).

Topic A4 is a Higher Level (HL) topic only, so everything here is examined at HL. This unit covers what machine learning actually is and the main types the course expects you to know: supervised, unsupervised and reinforcement learning, plus deep learning and transfer learning. It finishes with the hardware that machine learning runs on.

Topic A4 is Higher Level (HL) only. This unit is about how models are actually built and judged: preparing data, splitting it, spotting overfitting and underfitting, measuring performance with accuracy, precision, recall and F1, and tuning hyperparameters. It ends with the basics of artificial neural networks (ANNs), perceptrons and convolutional neural networks (CNNs).

Topic A4 is Higher Level (HL) only. This unit looks at where machine learning is used in the real world, at two unsupervised approaches (clustering and association rules), and at the ethical issues the course stresses, above all bias in training data and how to reduce harm.

Topic B4 (Abstract data types) is Higher Level only. This unit introduces what an ADT is and how it differs from a data structure, then looks at three building blocks: the stack (last-in, first-out), the queue (first-in, first-out) and the linked list (a chain of nodes joined by pointers). Get comfortable with the operations of each, because the rest of B4 builds on them.

Topic B4 is Higher Level only. This unit covers binary trees and, in particular, the binary search tree (BST), an ADT that keeps data sorted so it can be searched quickly. You need the terminology (root, parent, child, leaf, subtree), the left and right ordering rules, how to insert values and sketch the resulting tree, and the three traversal orders. Traversals are the highest-risk part, so work them out node by node.

Topic B4 is Higher Level only. This unit explains hash tables, the ADT behind fast key-value lookup, and how sets relate to them. You need to understand the three things that decide a hash table's performance: the hashing function, the collision resolution strategy and the load factor. A collision is not a bug, it is expected, so knowing how to resolve one is the key idea here.

Covers A1.1.7 (types of secondary storage) and A1.1.8 (compression). Both are core topics for SL and HL. You will learn how magnetic, solid-state and optical storage work, how to weigh them up on speed, capacity, cost, durability and volatility, and how lossless and lossy compression shrink files in different ways.

Covers A1.1.9 (cloud computing services) and A1.1.6 (pipelining and multi-core processing). Note: pipelining and multi-core processing (A1.1.6) are HL only and are marked (HL) in this unit; cloud computing (A1.1.9) is core for both SL and HL.

Programs constantly need to find data and put data in order. This unit covers the two search algorithms and two sort algorithms you need for IB Computer Science (B2.4.2 and B2.4.3), and how we measure their efficiency with Big O notation (B2.4.1). Knowing which algorithm to use, and why, is a common exam topic.

Higher Level only (B2.4.4 and B2.4.5). Recursion is when a function calls itself to solve a problem by breaking it into smaller versions of the same problem. This unit explains the base case and the recursive case, how the call stack works, how recursion compares with using a loop, and how to trace a simple recursive function such as factorial.

Data stored in variables and lists disappears when a program closes. Files let a program save data so it lasts, and load it back later. This unit (B2.5) covers why programs use files, how sequential files work, and how to read from and write to files, including the difference between overwriting and appending.

Higher Level (AHL) topic A3.4. A relational database is only one way to store data. This unit covers the other database models the course expects you to know, how data warehouses hold historical data for analysis, how OLAP and data mining turn that data into business intelligence, and how distributed databases spread data across many sites.

Higher Level (AHL) topic B3.2.5. A design pattern is a proven, reusable solution to a common design problem. This unit explains what a design pattern is, the three families they fall into, and the three patterns the course requires you to explain: singleton, factory and observer, and the problem each one solves.