What changes at HL

The same exams, extended

HL students sit the same two papers in structure as SL students, but longer, and every statement in the course can be examined, SL and HL alike. The SL papers never contain HL-only content; the HL papers contain everything. The course describes the HL difference as breadth and depth: an extra topic (B4, abstract data types), extra statements inside the SL topics, deeper research into the case study, and "networked knowledge", meaning more connections between different areas of the course.

In practice that gives three changes to prepare for. Paper 1 Section A reuses the SL questions and adds parts on HL-only topics. Paper 1 Section B is worth twice as much and draws on four case-study challenges instead of two. Paper 2 repeats two SL questions, including the no-code algorithmic thinking question, and fills the rest of its time with questions on HL-only programming topics.

HL Paper 1

Section A: SL questions with extra parts

HL Section A is made of the SL questions with additional question parts on HL-only topics in theme A. An extra part is likely to keep the context of the question it sits in: a question about a school network can gain a part on the TCP/IP model or on servers, and a database question can gain a part on aggregate functions or transactions. Nothing in the guide says the extra parts come only at the end of a question, so read every part in order.

The sports centre table Booking stores one row per court booking. An SL question about it might ask for a simple SELECT … WHERE; the HL extra part asks for a calculation.

The extra part tests HL knowledge in an SL setting, so the setting still matters. An answer that names the table's own columns and uses the scenario's numbers is marked as applied; a generic definition of an aggregate function is not.

Section B: four challenges

The case study booklet gives HL students four challenges to research instead of two, and Section B is worth 24 marks at HL against 12 at SL, with extended-response questions as well as short ones. The Exam skills page on the case study sets out the research plan and answer technique for both levels. At HL, give all four challenge sheets the same care, and expect at least one longer answer that weighs strategies using new stimulus material in the paper and ends in a justified recommendation.

HL Paper 2

The repeated SL questions

Two questions on HL Paper 2 are taken from the SL paper, and one of them is the algorithmic thinking question with no code. These are the questions with the most predictable shapes on the paper, so they are where well-practised technique earns marks fastest. Treat them exactly as an SL student would, without adding HL material they do not ask for.

The HL-only questions

The rest of HL Paper 2 covers the HL-only programming content of theme B. The command term of each statement sets the ceiling of what can be asked: a statement that says construct can ask you to write code, while one that says explain asks for reasons and diagrams.

Recursion and multi-class OOP each have a standard answer format worth practising; linked lists and sets are practised in subtopic B4.1, Fundamentals of ADTs. A recursion question is answered with a call table, which records each call, its parameters and its return value, because a normal trace table cannot show several unfinished calls at once. The function power raises a number to a whole-number power.

def power(base, exp):
    if exp == 0:
        return 1
    return base * power(base, exp - 1)


print(power(2, 5))

public class Power {
    public static int power(int base, int exp) {
        if (exp == 0) {
            return 1;
        }
        return base * power(base, exp - 1);
    }

    public static void main(String[] args) {
        System.out.println(power(2, 5));
    }
}

Multi-class OOP questions usually give a class and ask you to extend it. The class Ticket stores an event and a price; the subclass StudentTicket adds a school and overrides get_price to apply a 20% discount.

class Ticket:
    def __init__(self, event, price):
        self._event = event
        self._price = price

    def get_price(self):
        return self._price

    def describe(self):
        return self._event + ": " + str(self.get_price())


class StudentTicket(Ticket):
    def __init__(self, event, price, school):
        super().__init__(event, price)
        self._school = school

    def get_price(self):
        return self._price * 0.8


tickets = [Ticket("Concert", 12.5), StudentTicket("Concert", 12.5, "Westfield")]
total = 0
for t in tickets:
    print(t.describe())
    total = total + t.get_price()
print(total)

import java.util.ArrayList;

class Ticket {
    protected String event;
    protected double price;

    public Ticket(String event, double price) {
        this.event = event;
        this.price = price;
    }

    public double getPrice() {
        return price;
    }

    public String describe() {
        return event + ": " + getPrice();
    }
}

class StudentTicket extends Ticket {
    private String school;

    public StudentTicket(String event, double price, String school) {
        super(event, price);
        this.school = school;
    }

    @Override
    public double getPrice() {
        return price * 0.8;
    }
}

public class TicketDemo {
    public static void main(String[] args) {
        ArrayList<Ticket> tickets = new ArrayList<Ticket>();
        tickets.add(new Ticket("Concert", 12.5));
        tickets.add(new StudentTicket("Concert", 12.5, "Westfield"));
        double total = 0;
        for (Ticket t : tickets) {
            System.out.println(t.describe());
            total = total + t.getPrice();
        }
        System.out.println(total);
    }
}

Concert: 12.5
Concert: 10.0
22.5

In Java, price is protected in Ticket so the subclass can read it directly; if it were private, StudentTicket would have to call super.getPrice() instead. B3.2.1 names access to parent class members explicitly, so expect this rule to be tested. Python enforces no such rule; it relies only on the _price naming convention.

Questions that link topics

Networked knowledge shows up as questions whose parts come from different topics, joined by one context. A question on a hospital booking system could ask for a linked list of waiting patients (B4.1), a SQL query on the bookings (A3.3) and an explanation of why a hash table speeds up patient lookup (B4.1.6); a question on a game could combine a recursive function (B2.4.5) with a subclass hierarchy for game characters (B3.2). The linking questions printed at the end of each topic in the course, such as how stacks and queues relate to CPU interrupts, are good revision prompts for this style.

Pacing two-hour papers

Both HL papers last two hours for 80 marks, the same 1.5 minutes per mark as SL, so the pressure is the length rather than the speed. Long code answers in Paper 2 take more than their share of time if you start them without a plan, so sketch the structure first: the class header and attributes, the method headers, then the bodies. If a recursion or linked-list part stalls, write the parts you are sure of (the base case, the loop that walks the list) and move on, because each feature earns its own mark.

Checklist

• To do:

  I know that HL papers examine every statement, and that SL papers never contain HL-only content.

• To do:

  I expect HL extra parts inside SL questions in Paper 1 Section A, including in the middle of a question.

• To do:

  I can list the HL-only statements in theme A and the kind of part each could produce.

• To do:

  I have a challenge sheet for all four case-study challenges and have practised an extended Section B answer.

• To do:

  I know which two SL questions HL Paper 2 repeats, including the no-code question.

• To do:

  I can trace a non-branching recursive function with a call table and explain what happens without a reachable base case.

• To do:

  I can construct a subclass with a superclass constructor call and an overridden method in my language.

• To do:

  I can explain access to private, protected and public members from a subclass.

• To do:

  I can sketch and code linked-list operations and sketch a BST with its traversals.

• To do:

  I can write set operations and explain hash tables, collisions and load factor.

• To do:

  I tie every answer in a linked question back to its context.

• To do:

  I can pace an 80-mark, two-hour paper at 1.5 minutes per mark.