In simple terms
A friendly intro before the formal notes — no formulas yet.
Think Like a Computer Scientist
Computational thinking is a set of problem-solving methods that involve breaking down complex problems into smaller, more manageable parts. It's not about thinking like a computer, but rather thinking about the steps needed to solve a problem so that a computer could solve it.
Imagine you're asked to build a large, complex LEGO model without instructions. You wouldn't just start sticking bricks together randomly. First, you'd break the task down (decomposition): build the base, then the walls, then the roof. You'd spot repeating sections, like four identical towers (pattern recognition). You'd ignore the specific colour of a hidden internal brick, focusing only on its size and position (abstraction). Finally, you'd create a mental or written plan of the steps to build it (algorithm design).
- 1
Decompose the problem: Break the large, complex problem into smaller, simpler sub-problems.
- 2
Recognise patterns: Identify similarities or repeated processes among the sub-problems.
- 3
Use abstraction: Ignore irrelevant details and focus on the essential information needed to solve each sub-problem.
- 4
Design an algorithm: Create a step-by-step plan or set of rules to solve the problem, which can then be translated into code.
Explore the concept
Use the live diagram and synced steps — play it or tap a step card to walk through.
Full topic notes
Formal explanation with the rigour you need for the exam.
1. Decomposition: Breaking It Down
Decomposition is the art of taking a dauntingly large problem and breaking it into smaller, more manageable sub-problems. Think of it as creating a 'to-do' list for solving a problem. Instead of one big task, you have several small tasks that are easier to understand and tackle. In programming, these sub-problems often become separate functions or procedures, making your code modular and easier to debug.
Simplifies complex problems.
Allows for parallel development on different sub-problems.
Leads to modular program design (functions and procedures).
Makes testing and debugging more straightforward.
2. Pattern Recognition: Finding the Similarities
Once a problem is decomposed, you'll often notice that some of the sub-problems are very similar. Pattern recognition is the skill of identifying these similarities or repeated processes. Recognising a pattern allows you to design a single, reusable solution instead of creating multiple different ones. In programming, this is the principle behind using loops (for repeating actions) and functions (for repeating tasks with different inputs).
Identifies repeated structures or processes.
Leads to more efficient solutions.
Justifies the use of iteration (loops).
Enables the creation of general-purpose functions that can be reused.
3. Abstraction: Hiding the Detail
Abstraction is about simplifying things by ignoring the details that don't matter for the task at hand. It's the process of filtering out specific information and focusing on the general concepts. When you drive a car, you use the steering wheel, accelerator, and brake (the abstraction). You don't need to know the intricate details of the internal combustion engine. In programming, abstraction allows us to use variables to represent data, and functions to hide complex logic behind a simple name.
Removes unnecessary complexity.
Focuses on the 'what' rather than the 'how'.
Generalises problems to create solutions that work for many inputs.
Examples in programming include using variable names, data types, and function/procedure headers.
4. Algorithm Design: Creating the Plan
This is the culmination of the other three skills. Algorithm design involves developing the step-by-step instructions that will solve the problem. After decomposing the problem, recognising patterns, and abstracting away details, you are left with a clear set of requirements. Your algorithm is the precise plan that a computer can follow to turn the inputs into the desired outputs. This plan is typically written in pseudocode or a flowchart before being translated into a programming language.
Produces a step-by-step solution.
Is the logical plan for a program.
Should be unambiguous and precise.
Forms the basis for writing actual code.
Worked examples
See the formulas applied — reveal one step at a time, like the exam.
A teacher needs a program to calculate the average test score for a class of 30 students. The scores are integers out of 100. Describe how computational thinking could be used to solve this problem.
- 1
Decomposition: The problem can be broken down into smaller parts:
A program needs to find the highest temperature and the day it occurred from a week's worth of daily temperature readings. The readings are: Mon 22°C, Tue 25°C, Wed 24°C, Thu 28°C, Fri 27°C, Sat 23°C, Sun 26°C. Apply computational thinking to find the solution.
- 1
Decomposition: The problem can be split into:
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 consists of four key skills.
Key takeaways
Review these before you close the topic — retrieval beats re-reading.
- ✓
Simplifies complex problems.
- ✓
Allows for parallel development on different sub-problems.
- ✓
Leads to modular program design (functions and procedures).
- ✓
Makes testing and debugging more straightforward.
Practice — then mark it
The whole point: a real Cambridge question, marked mark-by-mark.
Test Your Skills on Computational Thinking
Test Your Skills on Computational Thinking
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 Skills on Computational Thinking on paper, snap a photo, and get examiner-style feedback on exactly where you win and lose marks.