Computer Science (SL/HL)

Computer Science is about solving real problems with code.

It combines three skills you need to master simultaneously: understanding how computers and networks actually work (systems thinking), designing step-by-step solutions to problems (algorithmic thinking), and writing code that runs reliably (programming). Most students find this combination harder than they expect. It's not that the theory is too difficult or the coding is too hard. It's doing both at once, under exam pressure, while also creating something original for your Internal Assessment that proves you own the thinking.

What the course covers

The DP course is organized into two themes. Theme A focuses on concepts in computer science: how computing systems work, including networks, databases, and machine learning. Theme B focuses on computational thinking and problem-solving—how you take a real-world problem, break it down algorithmically, and implement a solution in code. You can study in either Python or Java, depending on what your school teaches.

SL vs HL: The key difference

At SL, you master the core concepts and learn to code solutions to defined problems. At HL, you go deeper into algorithmic complexity and object-oriented programming (OOP) and abstract data types. The HL syllabus requires you to think about how data structures and design patterns make code more maintainable and efficient, not just whether it works. HL also weighs your Internal Assessment less heavily (20% of your grade at HL vs. 30% at SL), but the exam demands are steeper.

Challenge 1: Translating real problems into computational terms

Many students struggle to move from "I understand how a network works" to "I can design an algorithm that solves this specific problem." This requires you to specify success criteria, identify constraints, and think in steps before you write a single line of code. In Paper 1, you answer questions on Theme A concepts, including three questions on a case study chosen by the IB. In Paper 2, you face problems that require you to write working code in Java or Python under timed conditions. The leap from understanding a concept to implementing it under pressure is where most students feel the gap.

Challenge 2: The Internal Assessment—ownership of a computational solution

You must identify a real-world problem of your own choosing, design a solution, code it, test it, and evaluate whether it actually works. This is not a guided project. You choose the problem scope, define what success looks like, and defend your design decisions. Many students either pick problems that are too vague or too ambitious, or they struggle with the evaluation phase—explaining honestly whether their solution succeeded and why or why not. Examiners want to see your thinking, not a polished product. This is where academic integrity shines through: your code is yours, your decisions are yours, your evaluation is honest.

Challenge 3: Balancing systems theory with implementation reality

You need to know how encryption works, how databases are structured, how machine learning models train. But you also need to write code that handles edge cases, validates input, and doesn't crash when something unexpected happens. In Paper 2, programming questions have equivalent versions in Java and Python—but the language itself becomes a source of stress for some students. If you're weaker in syntax or debugging, the conceptual solution gets lost in implementation details.

What intensifies at HL

At HL, the assessment demands deeper algorithmic knowledge (Big O notation, sorting algorithms, recursion patterns). Object-oriented programming isn't just "classes exist." You need to design class hierarchies, understand inheritance and polymorphism, and choose the right design pattern for a problem. Abstract data types mean you're not just using a list; you're understanding why a linked list, a stack, or a queue is the right choice for a specific algorithm. Papers 1 and 2 are both 2 hours at HL (vs. 1 hour 15 minutes at SL), and the questions assume you can implement and justify complex solutions, not just explain concepts.