Curriculum map

Course map

See the complete Code Companion programming journey and how each technique maps to the IB Diploma Programme Computer Science standards it deliberately teaches and practises.

26 TECHNIQUES · JAVA + PYTHON

The programming journey at a glance

Follow the route from core programming foundations through data, algorithms and object-oriented programming. HL-only content is marked clearly.

Programming foundations

9 techniques

T01 Sequence B2.3.1 T02 Variables B2.1.1 T03 Strings B2.1.2 T04 Arithmetic B2.1.1 T05 Debugging B2.1.3 · B2.1.4 T06 Selection B2.3.2 T07 Counted loops B2.3.3 T08 Conditional loops B2.3.3 T09 Functions B2.3.4

Data, files and algorithms

8 techniques

T10 Arrays and lists B2.2.1 · B2.2.2 T11 Stacks B2.2.3 T12 Queues B2.2.4 T13 Big O B2.4.1 T14 Searching B2.4.2 T15 Sorting B2.4.3 T16 Recursion B2.4.4 · B2.4.5 T17 Files B2.5.1

Object-oriented programming

4 techniques

T18 Why OOP? B3.1.1 T19 Classes B3.1.2 · B3.1.4 T20 Members B3.1.3 T21 Encapsulation B3.1.5

HL object-oriented programming

5 techniques · HL only

T22 Inheritance B3.2.1 T23 Polymorphism B3.2.2 T24 Abstraction B3.2.3 T25 Composition B3.2.4 T26 Patterns B3.2.5

26 techniques

T01–T26 form the published programming sequence.

B2 programming

Covered through explanations, worked examples, checks and challenges.

B3 OOP

Covered for shared SL/HL B3.1 and HL-only B3.2.

B1 / B4

Separate or embedded rather than presented as completed programming techniques.

Challenge evidence is practice evidence, not proof of mastery: a challenge shows that the standard is deliberately practised on the site. Teachers still need classroom questioning, observation and controlled assessment to judge what a student can do independently.

Language selection: Java and Python cover the same standard-level intent, while pages change syntax, libraries, scaffolds and language-specific explanations.

DETAILED AUDIT

IB standards coverage

Use this table to check exactly where a standard is explained, practised, embedded or intentionally kept separate from the programming sequence.

IB standard	Focus	Technique(s)	Explained here	Challenge evidence	Notes
B1.1.1	Construct a problem specification	—	Embedded	Partial	Challenge tasks provide specifications; student-authored specifications remain a separate computational-thinking emphasis.
B1.1.2–B1.1.3	Computational-thinking concepts and application	—	Embedded	Partial	Used throughout decomposition, pattern recognition, abstraction, algorithm design and modular problem solving.
B1.1.4	Trace flowcharts	—	Separate	No	Flowcharts appear where they support programming ideas, but formal tracing practice is taught separately.
B2.1.1	Variables, scope and data types	T02 Variables and input T04 Arithmetic, random numbers and conversion	Yes	Yes	Global/local scope, Boolean, character, decimal, integer and string data, arithmetic, conversion, input and tracing.
B2.1.2	Substring extraction and manipulation	T03 String manipulation	Yes	Yes	Indexing, extraction, alteration, concatenation and replacement.
B2.1.3	Exception-handling techniques	T05 Debugging and exceptions	Yes	Yes	Unexpected input, unavailable resources, error-handling purpose, specific handlers and finally.
B2.1.4	Debugging techniques	T05 Debugging and exceptions	Yes	Yes	Trace tables, breakpoint debugging, print evidence and step-by-step execution.
B2.2.1	Static and dynamic data structures	T10 Arrays and lists	Yes	Yes	Memory allocation/resizing plus speed, memory-use and flexibility trade-offs.
B2.2.2	Arrays and lists	T10 Arrays and lists	Yes	Yes	1D, 2D and dynamic collections including add, remove and traversal.
B2.2.3	Stacks and LIFO	T11 Stacks	Yes	Yes	Operations, traces, qualitative performance/memory impact, safety and suitability.
B2.2.4	Queues and FIFO	T12 Queues	Yes	Yes	Operations, traces, qualitative performance/memory impact, safety and suitability.
B2.3.1	Sequence of instructions	T01 Sequence and output	Yes	Yes	Instruction order, correct output and the effect of changing sequence.
B2.3.2	Selection structures	T06 Selection	Yes	Yes	if/else chains, Boolean operators and relational operators, then reuse inside larger programs.
B2.3.3	Looping structures	T07 Counted loops T08 Conditional loops	Yes	Yes	Counted and conditional loops, appropriate loop choice, loop conditions and selection inside repetition.
B2.3.4	Functions and modularisation	T09 Functions and modularisation	Yes	Yes	Inputs, returns, local/global scope, reuse, maintainability and scenario-based benefits.
B2.4.1	Algorithm efficiency and Big O	T13 Algorithm efficiency and Big O	Yes	Yes	Time/space complexity, O(1), O(log n), O(n), O(n²), dominant growth and scalability.
B2.4.2	Linear and binary search	T14 Linear and binary search	Yes	Yes	Construction, tracing, sorted-data precondition, efficiency comparison and technique choice.
B2.4.3	Bubble and selection sort	T15 Bubble sort and selection sort	Yes	Yes	Construction, pass tracing, time/space complexity and balanced evaluation across data sets.
B2.4.4–B2.4.5	Recursion (HL)	T16 Recursion	Yes	Yes	Base/recursive cases, winding/unwinding, applications and simple non-branching recursive construction.
B2.5.1	File-processing operations	T17 File processing	Yes	Yes	Sequential text files, read/write/append effects and reliable closure.
B3.1.1	Evaluate OOP fundamentals	T18 Why object orientation?	Yes	Yes	Balanced scenario judgement rather than universal advocacy.
B3.1.2	Design classes, methods and behaviour	T19 Classes and objects	Yes	Yes	Requirement-led UML and matching class designs.
B3.1.3	Class-owned and instance-owned members	T20 Class and instance members	Yes	Yes	Ownership, scope and suitability are implemented with the selected language model.
B3.1.4	Define classes and instantiate objects	T19 Classes and objects	Yes	Yes	Initialisation, objects, receivers and independent instance state.
B3.1.5	Encapsulation and information hiding	T21 Encapsulation and information hiding	Yes	Yes	Controlled state, deliberate interfaces and valid-state protection; Python differences are explicit.
B3.2.1	Inheritance and code reusability (HL)	T22 Inheritance	Yes	Yes	Parent–child hierarchies, parent initialisation, access impact and is-a judgement.
B3.2.2	Polymorphism and method overriding (HL)	T23 Polymorphism	Yes	Yes	Dynamic overriding and runtime method selection through a shared role, plus a bounded Java overloading comparison for static polymorphic behaviour.
B3.2.3	Abstraction and abstract classes (HL)	T24 Abstraction and abstract classes	Yes	Yes	Abstract superclasses, required operations, shared implemented behaviour, non-instantiability, modular callers and the distinction from encapsulation.
B3.2.4	Composition and aggregation (HL)	T25 Composition and aggregation	Yes	Yes	Whole–part relationships classified through ownership and meaningful independent lifetime, with filled/hollow UML diamonds.
B3.2.5	Design patterns (HL)	T26 Singleton, Factory and Observer	Yes	Yes	Singleton, Factory and Observer taught from recurring design problems, with small implementations, application judgements and explicit benefits/trade-offs.
B4.1.1–B4.1.6	Abstract data types (HL)	—	Separate	No	Outside the current practical companion sequence; retained as a later HL section.

HL boundaries: T16 recursion covers HL-only B2.4.4–B2.4.5. T22–T26 cover HL-only B3.2.1–B3.2.5. B4 abstract data types are not being marked complete here because they remain outside the current published practical sequence.