Present the scenario: An alien has arrived and wants to understand how humans make tea. They've never seen a kettle, cup, tea bag, or even water. Students work in pairs for 2 minutes to write instructions. Share some examples - they'll be hilariously over-complicated or miss obvious steps. Use this to introduce why we need systematic ways to break down problems.

Introduce each principle with a relatable example:

Decomposition: Show a complex task (planning a school trip) and break it into sub-tasks (transport, permissions, activities, food, first aid). Like taking apart a LEGO set to see the individual bricks.

Abstraction: Using the London Tube map as the classic example - it removes geography, scale, and surface details to show only what matters (stations and lines). Students identify what was removed and why.

Algorithmic Thinking: The recipe analogy - turning a problem into step-by-step instructions that anyone could follow. Show how our alien tea instructions are an algorithm.

Groups of 3-4 receive a complex task card (e.g., 'Organise a birthday party', 'Create a mobile app', 'Run a school football tournament'). They must decompose it into at least 6 sub-tasks, then pick ONE sub-task and decompose it further. Groups share their decompositions. Discuss: at what point do you stop breaking things down?

Quick individual task: Students draw a simplified map showing how to get from the school entrance to this classroom. They must decide what to include (which corridors, doors, stairs) and what to abstract away (every single classroom, bathroom locations, fire extinguishers). Compare a few - why did different people include different details? The PURPOSE of the abstraction determines what's relevant.

Brief, inspiring aside: Show how Minecraft procedurally generates worlds using algorithmic thinking, and how games like FIFA decompose a football match into component systems (physics, AI, graphics, sound). Link to careers: Game designers, UX designers, project managers all use these skills.

Students write definitions of abstraction, decomposition, and algorithmic thinking - but each definition can only be THREE WORDS (e.g., 'hiding unnecessary details', 'breaking things down', 'step-by-step instructions'). Share and vote on the best ones. Exit ticket: Which computational thinking principle would help most with homework organisation?

Show a video or animation of a vending machine. Ask students: What's the INPUT? (money, button press) What's the PROCESS? (check money, release item) What's the OUTPUT? (snack, change). Now apply to Instagram: INPUT = photo + filters + caption, PROCESS = compress, store, distribute to followers, OUTPUT = post visible to everyone. The IPO model is everywhere.

Formal introduction to IPO with multiple examples:

1. Calculator: Input (numbers, operation), Process (perform calculation), Output (result)
2. Spell checker: Input (word), Process (compare to dictionary), Output (correct/incorrect + suggestions)
3. Traffic light system: Input (timer, sensors), Process (check timing, detect cars), Output (light colours)

Emphasise: The same problem can have different valid IPO descriptions depending on what level of detail you're working at.

Show how decomposition can be visualised using structure diagrams (also called hierarchy charts). Start with 'Make a Video Game' at the top, decompose into Graphics, Sound, Gameplay, User Interface. Decompose Gameplay further into Player Controls, Enemy AI, Scoring System. Explain: the diagram shows WHAT needs to be done, not HOW or in what ORDER (that comes later with algorithms).

Pairs receive scenario cards and must identify inputs, processes, and outputs. Scenarios increase in difficulty:

• Easy: Password checker (input: password, process: compare to stored value, output: access granted/denied)
• Medium: Weather app (multiple inputs: location, sensors; multiple processes; multiple outputs)
• Hard: Recommendation system like YouTube (what ARE the inputs?)

Share and discuss - especially the harder ones where there's genuine debate about what counts as an input.

Students create a structure diagram for 'Run a School Canteen' or 'Organise a Music Festival' (their choice). Must include at least 3 levels of decomposition. Work individually first, then compare with a partner - did they decompose in the same way? Discuss: there's rarely ONE correct decomposition.

Quick-fire questions testing understanding:

1. Give one input to a car navigation system (GPS coordinates, destination, traffic data)
2. What's the main process of a search engine? (Match search terms to indexed pages, rank results)
3. True or false: A vending machine has no outputs if you don't put money in (False - it might output an error message or 'insert coins' display)

Exit question: What inputs, processes, and outputs would a game like Wordle have?

Show the famous NASA Mission Control room photo. Explain: Before any code was written for Apollo 11, everything was planned using flowcharts. Show a (simplified) example of a NASA-era flowchart. Challenge: Could students draw instructions clear enough that Mission Control could follow them? Today, they'll learn how.

Introduce each symbol with examples:

• Oval/Terminal: Start and End points
• Parallelogram: Input/Output (data in or out)
• Rectangle: Process (an action or calculation)
• Diamond: Decision (yes/no question)
• Arrow: Flow direction
• Rectangle with double sides: Subroutine/sub-program

Demonstrate building a simple flowchart live: 'Is this number positive, negative, or zero?'

Give students three flowcharts to trace through. For each, they determine the output given specific inputs:

1. Simple sequence (no decisions)
2. Single selection (one if-statement equivalent)
3. Loop (while loop equivalent)

Work through first one together, then independent practice. Share and check answers.

Students create a flowchart for: 'Decide if someone can ride a rollercoaster based on height (must be at least 140cm)'. Must include: Start, input (height), decision, outputs for both paths, End. Then extend: Add a second check - are they feeling unwell?

Students draw on paper or use digital tool (Lucidchart/Draw.io have free tiers).

Present three deliberately broken flowcharts. Students identify what's wrong:

1. No Start symbol
2. Decision with only one exit
3. Infinite loop (no escape condition)
4. Missing arrows (ambiguous flow)

Discuss why each matters - unclear flowcharts lead to buggy code.

Quick challenge: Draw a flowchart for 'Check if a password is at least 8 characters long'. 3 minutes individual work, then swap with partner. Partner traces through with test data: 'hello' (should output 'too short'), 'password123' (should output 'valid'). Did the flowchart work correctly?

Show the Rosetta Stone image. Explain: It let people translate between Egyptian hieroglyphics and Greek. Pseudocode is like that for programming - it's a common language that can be 'translated' into any programming language. Show the same algorithm in pseudocode, Python, and JavaScript - the logic is identical, only the syntax changes.

Introduce the OCR reference language with examples:

Variables and I/O:

name = input("Enter your name")
print("Hello " + name)

Selection:

if age >= 18 then
    print("Adult")
else
    print("Minor")
endif

Iteration:

for i = 1 to 5
    print(i)
next i

while count < 10
    count = count + 1
endwhile

Emphasise: Indentation matters for readability!

Introduce nesting - putting loops inside loops, or if-statements inside loops. Show example: printing a times table (outer loop for rows, inner loop for columns). Trace through together showing how the indentation helps us track which 'level' we're at. Common exam scenario: understanding what nested loops produce.

Students receive flowcharts from last lesson (or new ones provided) and must convert them to pseudocode. Start with a simple sequence, then one with a decision, then one with a loop. Compare translations - there may be valid variations.

Write pseudocode for: 'A program that asks for 5 test scores, calculates the average, and outputs whether the student passed (average >= 50) or failed.'

This requires:

• A loop (to input 5 scores)
• A running total (aggregation)
• A calculation (average = total / 5)
• Selection (if-else for pass/fail)

Work individually, then compare solutions.

Give pseudocode for a simple algorithm. Students must:

1. Draw the flowchart equivalent (quick sketch)
2. State what the algorithm does in one sentence
3. Give the output if input is [specific value]

This tests understanding in multiple representations.

Show the famous photo of the moth taped into Grace Hopper's logbook from 1947 - labelled 'first actual case of bug being found'. Explain: Debugging has been part of computing since the very beginning. Today, students become detectives who solve code crimes using evidence (trace tables) and deduction.

Introduce trace tables: a systematic way to track variable values as an algorithm executes.

Example algorithm:

count = 0
total = 0
for i = 1 to 3
    num = input()
    total = total + num
    count = count + 1
next i
average = total / count
print(average)

Draw trace table with columns: i, num, total, count, output. Work through with inputs 4, 6, 5. Show how each row represents one 'moment' in time.

Two types of errors that haunt programmers:

Syntax errors: Breaking the grammar rules of the language. The program won't run at all.

• Missing quote marks
• Misspelled keywords (pritn instead of print)
• Forgetting colons or brackets

Logic errors: The program runs but does the wrong thing.

• Using + instead of -
• Loop runs too many/few times
• Wrong comparison operator (< instead of <=)

Show examples of each. Which is easier to find? (Syntax - the computer tells you!)

Students complete trace tables for two algorithms:

1. A counting loop (simpler - just track i and total)
2. A loop with a condition inside (track multiple variables, some values change, some don't)

Provide input values. Students compare answers - any differences? Who's right?

Present 4-5 code snippets, each with ONE error. Students identify:

1. Is it syntax or logic?
2. What line is the error on?
3. How would you fix it?

Examples:

• print(Hello) - missing quotes (syntax)
• if age > 18 when it should be >= 18 (logic)
• for i = 1 to 10 ... next j (syntax - wrong variable)
• total = total - num instead of + (logic)

Show a complete algorithm that doesn't work correctly. Students must:

1. Use a trace table to discover what it actually does
2. Identify what it SHOULD do (from context/comments)
3. Find and fix the error(s)

This combines all skills from the lesson into one problem.

Pose the question: How do you find 'Python' in a dictionary? Ask students to describe their actual strategy. They'll say something like 'open to the middle, it's after M, so go to the second half...' - they're already doing binary search! But what if the dictionary wasn't alphabetical? (That's linear search.) Set up the lesson: Today we formalise what they already intuitively understand.

Explain linear search: Check each item in order until you find what you're looking for.

Example: Find 27 in [4, 17, 8, 27, 11, 6]

• Check index 0 (4) - not 27
• Check index 1 (17) - not 27
• Check index 2 (8) - not 27
• Check index 3 (27) - FOUND! Return 3

Pseudocode:

for i = 0 to length(list) - 1
    if list[i] == target then
        return i
    endif
next i
return -1 // not found

Ask: What's the worst case? (Item at the end, or not there at all)

Explain binary search: Repeatedly divide the search space in half.

Example: Find 27 in [4, 6, 8, 11, 17, 23, 27, 31]

• Middle element is 11. Is 27 > 11? Yes, so search right half.
• Now searching [17, 23, 27, 31]. Middle is 23. Is 27 > 23? Yes.
• Now searching [27, 31]. Middle is 27. FOUND!

Only 3 comparisons instead of 7!

CRITICAL: List MUST be sorted. Why? (If not sorted, we can't know which half to keep.)

Line up 8-10 students holding number cards (sorted). One student is the 'searcher'. They must find a target number using only binary search rules:

• Ask the middle person: 'Is your number [target]?'
• If not, ask: 'Is [target] higher or lower?'
• Eliminate half and repeat.

Run several times. Count comparisons. Compare to if they'd checked one by one.

Create comparison table:

For 1 million items: Linear might need 1,000,000 checks. Binary needs max 20.

Scenarios to consider:

1. Searching for a word in a sorted dictionary app - Binary
2. Finding a name in a list of guests as they arrive (added in no order) - Linear
3. Checking if a username already exists in a database of 10 million users - Binary (sorted index)
4. Looking for your lost sock in a drawer - Linear (socks aren't sorted!)

Exit ticket: Trace through binary search for finding 35 in [5, 12, 17, 25, 35, 42, 58, 67]

Give each table group 10 shuffled playing cards. Challenge: Sort them from lowest to highest using a METHOD you could explain to someone who can only do one thing - compare two adjacent cards and swap if needed. Let them try. They'll probably naturally do something like bubble or insertion sort. Ask: 'What was your strategy?'

Explain bubble sort: Larger values 'bubble up' to the end through repeated adjacent swaps.

Example: Sort [5, 2, 8, 1, 9]

Pass 1:

• Compare 5,2 → swap → [2,5,8,1,9]
• Compare 5,8 → no swap
• Compare 8,1 → swap → [2,5,1,8,9]
• Compare 8,9 → no swap

After pass 1: 9 is in correct position. Repeat for remaining items.

Key insight: After each pass, one more item is in its final position.

Explain insertion sort: Build a sorted section one item at a time, inserting each new item in its correct position.

Example: Sort [5, 2, 8, 1, 9]

• Start: [5] is trivially sorted
• Take 2: Insert into correct position → [2, 5]
• Take 8: Insert (already in correct position) → [2, 5, 8]
• Take 1: Insert at start → [1, 2, 5, 8]
• Take 9: Insert at end → [1, 2, 5, 8, 9]

Key insight: The left portion is always sorted.

Get 6-8 volunteers holding number cards in a shuffled line. Rest of class calls out instructions:

For bubble sort: 'Compare positions 1 and 2. Swap? Now 2 and 3...'

For insertion sort: 'First person, stand still. Second person, where do you go? Third person...'

Compare how many swaps/comparisons each needed.

Create comparison table:

Both are 'simple' sorts used for teaching. Neither is used for large-scale real applications (that's merge sort, coming next lesson!).

Show pseudocode/Exam Reference Language for bubble and insertion sort. Without telling them which is which, ask students to identify which algorithm matches each code. Then trace through one with a specific list.

Exit ticket: Given list [7, 3, 9, 5], show the first 2 passes of bubble sort.

Tell students: 'I'm going to teach you a sorting algorithm where you never compare more than two items at a time, and yet it's much faster than bubble sort for large lists. The secret? We're lazy in a clever way.' Set up the mystery: how can doing LESS lead to BETTER results?

Start with: [8, 3, 5, 1, 9, 2, 7, 4]

Step 1: Split into two halves. [8, 3, 5, 1] and [9, 2, 7, 4]

Step 2: Keep splitting until you have single items. [8] [3] [5] [1] [9] [2] [7] [4]

A single item is... already sorted! This is our base case. Now what?

Now we merge sorted lists together:

Merge [8] with [3]: Compare, 3<8, so [3, 8] Merge [5] with [1]: Compare, 1<5, so [1, 5]

Merge [3, 8] with [1, 5]:

• Compare 3 and 1: 1 is smaller, take it → [1]
• Compare 3 and 5: 3 is smaller, take it → [1, 3]
• Compare 8 and 5: 5 is smaller, take it → [1, 3, 5]
• Only 8 left, take it → [1, 3, 5, 8]

The magic: merging two SORTED lists is easy and fast!

Students trace merge sort on: [6, 2, 8, 4, 3, 7, 1, 5]

1. Draw the divide tree (splitting until single items)
2. Work back up, showing each merge step
3. Show the final sorted list

Work in pairs. Compare trees - should all look the same for the divide stage.

Compare to bubble sort:

Bubble sort on 8 items: Could need 8×7÷2 = 28 comparisons (worst case) Merge sort on 8 items: 3 levels of splitting, about 8 comparisons per level = ~24 comparisons

But for 1000 items: Bubble sort: Up to 500,000 comparisons Merge sort: About 10,000 comparisons

Merge sort scales much better because it divides the problem!

Show the intermediate stages of three different sorts (bubble, insertion, merge) on the same starting data. Students must identify which is which by looking at the 'state' after a few operations.

Exit ticket: What is the main advantage of merge sort over bubble and insertion sort? (Efficiency on large data sets / divide and conquer approach)

Present 'trading cards' for each algorithm with 'stats' like: Speed (best/worst case), Memory use, Difficulty to code, Works on unsorted data? etc. Which algorithms are strong in which situations? Like choosing the right tool for a job.

Build a comprehensive comparison table together:

Discuss: When would you choose each?

Show code snippets (in pseudocode or Python/OCR reference language) for each algorithm learned. Students must identify:

1. Which algorithm is this?
2. What key features give it away?
3. What would the output be for given input?

Cover: Linear search, binary search, bubble sort, insertion sort, merge sort (showing either divide or merge phase).

Groups receive scenario cards and must recommend which algorithm to use and justify:

1. 'Searching a phone contacts list with 500 names' → Binary search (sorted, large enough to benefit)
2. 'Sorting a hand of 5 playing cards' → Insertion sort (small, human-like)
3. 'Finding if a specific word appears in a document' → Linear search (text isn't numerically sorted)
4. 'Sorting 100,000 customer records by surname' → Merge sort (large dataset)
5. 'Finding a book in an unsorted pile of 20 books' → Linear search (unsorted)

Defend choices - there may be valid alternatives!

Timed exam-style questions:

1. Trace binary search for finding 25 in [5, 10, 15, 20, 25, 30, 35] - show all comparisons (3 marks)
2. After one complete pass of bubble sort on [9, 3, 7, 2, 8], what is the list? (2 marks)
3. Explain one advantage and one disadvantage of merge sort compared to bubble sort. (4 marks)

Mark together and discuss approach.

Students vote on 'awards' for algorithms:

• 'Most Likely to Succeed' (most useful overall)
• 'Best Under Pressure' (fastest for big problems)
• 'Most Underrated' (useful but often overlooked)
• 'Class Clown' (takes longest but everyone knows it - bubble sort!)

Reflect: What's the most important thing you've learned about algorithms in this unit?