In simple terms
A friendly intro before the formal notes — no formulas yet.
Thinking Like a Problem-Solver
Computational thinking is a powerful method for solving complex problems by breaking them down into simpler pieces. It involves focusing only on the essential details and then creating a clear, step-by-step plan to reach the solution.
Imagine you have to build a large, complex LEGO model. First, you wouldn't just tip all the bricks out and start randomly connecting them. You'd use decomposition to sort the pieces by colour and shape, and build the model in sections (e.g., the base, the walls, the roof). You'd use abstraction by ignoring the tiny manufacturing numbers inside each brick, as they are irrelevant to building the model. Finally, you'd follow the instruction booklet step-by-step, which is your algorithm.
- 1
Decompose the problem: Break a large, complex problem into smaller, more manageable sub-problems.
- 2
Abstract the details: For each sub-problem, identify the crucial information and ignore irrelevant details.
- 3
Design the algorithm: Create a precise, step-by-step sequence of instructions to solve each sub-problem.
- 4
Evaluate and generalise: Test the solution to ensure it works correctly and consider how it could be adapted for similar problems.
Explore the concept
Use the live diagram and synced steps — play it or tap a step card to walk through.
Key formulas
Tap any symbol to reveal exactly what it means and its units.
$DECLARE variable1 = initial_value$
Full topic notes
Formal explanation with the rigour you need for the exam.
Decomposition: Breaking Down the Beast
Complex problems are often overwhelming. Decomposition is the strategy of breaking a large, complex problem into smaller, more manageable sub-problems. The goal is to create sub-problems that are easier to understand, program, and test. For example, developing a social media platform would be decomposed into tasks like user authentication, news feed generation, private messaging, and profile management. Each of these can be developed and tested by separate teams or at different times.
Makes problems easier to manage and understand.
Allows for parallel development, where different teams can work on different parts simultaneously.
Simplifies the testing and debugging process, as you can isolate faults to specific components.
Abstraction: Seeing the Wood for the Trees
Abstraction is the art of removing unnecessary detail to focus on the essential characteristics of a problem. It's about creating a simplified model of a complex reality. When you drive a car, you use the steering wheel, accelerator, and brake – this is an abstraction. You don't need to know about the internal combustion engine, the fuel injection system, or the precise mechanics of the disc brakes. In programming, we use abstraction constantly, for example, by using variables to store data without needing to know the specific memory address where the data is physically located.
Reduces complexity by hiding irrelevant details.
Focuses on the 'what' rather than the 'how'.
Helps in creating generalisable solutions that are not tied to specific, unnecessary details.
Algorithms: The Recipe for Success
Once a problem has been decomposed and abstracted, you need a plan to actually solve it. An algorithm is that plan. It's a finite, ordered, and unambiguous set of steps to solve a problem. Think of it as a recipe: it lists the ingredients (inputs), provides step-by-step instructions, and results in a finished dish (output). In computer science, we often express algorithms using flowcharts or pseudocode before writing them in a specific programming language.
// Basic Algorithm Structure in Pseudocode
PROCEDURE solveProblem(parameters) // Step 1: Initialise variables DECLARE variable1 = initial_value
// Step 2: Process data (e.g., using loops, conditionals) LOOP for each item in data IF condition is true THEN // perform action END IF END LOOP
// Step 3: Return the result RETURN result END PROCEDURE
In Paper 1, questions on computational thinking are often scenario-based. You will be given a real-world problem and asked to apply decomposition or abstraction. Be specific in your answers. Don't just say 'break the problem down'; state what the sub-problems would be. Don't just say 'remove details'; state which specific details are irrelevant and why.
Worked examples
See the formulas applied — reveal one step at a time, like the exam.
A school wants to create a software system to manage its sports day. The system should handle student registration for events, record results, and calculate house points. Using decomposition and abstraction, outline the main components and key data requirements for this system.
- 1
Student Registration Module: Allows students to sign up for specific events. [1 mark]
An environmental sensor records air quality as a value from 0 (good) to 500 (hazardous). The sensor sometimes malfunctions, returning a value of -999. Design an algorithm in pseudocode that takes an array of 100 readings, calculates the average air quality, and ignores any malfunction readings. It should also count how many malfunctions occurred.
- 1
Initialise variables for the sum of valid readings (totalQuality), the count of valid readings (validCount), and the count of malfunctions (malfunctionCount).
How it all connects
The big idea sits in the middle — tap a linked idea to explore the link.
Tap a linked idea to see how it connects back to the main topic — that connection is what examiners reward.
Glossary
Try to recall each definition before you reveal it.
Quick check
Answer in your head first — then tap to check. No pressure.
Revision flashcards
Flip the card. Test yourself before the exam.
What is Computational Thinking?
A problem-solving process that involves formulating a problem and its solution in a way that a computer (human or machine) can effectively carry out. It includes decomposition, abstraction, pattern recognition, and algorithm design.
Key takeaways
Review these before you close the topic — retrieval beats re-reading.
- ✓
Makes problems easier to manage and understand.
- ✓
Allows for parallel development, where different teams can work on different parts simultaneously.
- ✓
Simplifies the testing and debugging process, as you can isolate faults to specific components.
Practice — then mark it
The whole point: a real Cambridge question, marked mark-by-mark.
Test Your Computational Thinking Skills
Test Your Computational Thinking Skills
Extra simulations & links
PhET, GeoGebra and other curated tools — open in a new tab.
Frequently asked
Checkpoint
One marked question is worth ten re-reads — close the loop before you move on.
Reading it isn’t knowing it — prove it.
Before you move on: do Test Your Computational Thinking Skills on paper, snap a photo, and get examiner-style feedback on exactly where you win and lose marks.