Computational Thinking
Every day, computers help us solve problems that would take a person hours — finding the quickest route home, sorting thousands of songs, or checking millions of records in seconds. But a computer cannot work anything out for itself. Before a problem can be handed to a machine, a human has to work out exactly how it will be solved. Computational thinking is the name we give to this way of tackling problems, and it is the foundation of everything a programmer does.
Computational thinking is built on three main principles: abstraction, decomposition and algorithmic thinking. Used together, they turn a large, messy, real-world problem into something precise enough for a computer to handle. This lesson looks at each principle in turn and then shows how they work together.
Abstraction
Abstraction means removing or hiding the details that do not matter, so that you can focus on the information that does. Almost every problem contains detail that is not needed to solve it. Filtering that detail out makes the problem simpler and much easier to work with.
A classic example is the London Underground map designed by Harry Beck. A real, geographically accurate map of the tunnels would be cluttered and confusing. Beck’s design throws away the true distances and the exact positions of the stations, and keeps only what a passenger actually needs: the order of the stations, which line each one is on, and where the lines connect. As geography the map is ‘wrong’, yet it is far more useful for planning a journey — that is abstraction at work.
Abstraction is everywhere in computing. When you drive a car, the steering wheel and pedals let you control the vehicle without knowing how the engine works — the mechanical detail is hidden from you. In a program, giving a value a sensible name such as score or playerName is abstraction too: the name lets you think about what the data means while hiding the binary and memory details underneath.
Abstraction removes unnecessary detail while keeping the key details needed to solve the problem. It does not mean throwing everything away — it means deciding what matters and what can be ignored.
Decomposition
Decomposition means breaking a big, complicated problem into smaller parts. Each smaller part is called a sub-problem, and each one can be solved on its own. Trying to solve one huge problem all at once is hard; solving a series of small, clear problems is far more manageable.
Imagine you are asked to write a quiz app. As one giant task it feels overwhelming, and it is difficult to even know where to begin. Once it is decomposed, it becomes a list of smaller jobs that you can tackle one at a time.
A quiz app might break down into these sub-problems:
- store the questions along with their correct answers
- display one question at a time to the player
- collect the player’s answer and check whether it is correct
- keep a running score and show the final result at the end
Each sub-problem is small enough to solve, test and fix on its own. Decomposition also lets a team split the work between them, and a solved sub-problem — such as keeping score — can often be reused in a completely different program.
Algorithmic thinking
Algorithmic thinking is working out the exact steps needed to solve a problem, in the right order. The result of this thinking is an algorithm — a clear set of instructions that reliably leads to the correct result.
You already use algorithms in everyday life. A recipe is an algorithm: a list of steps, in order, that turns raw ingredients into a finished meal. Directions to a friend’s house are an algorithm too. If the steps are muddled, or a step is missing, you end up with the wrong result.
Algorithmic thinking means being precise. A computer follows instructions exactly, so a vague step like ‘check the answers’ is not enough. You have to spell each step out: get the player’s answer, compare it with the correct answer, and if they match, add one to the score. Spotting repeated patterns — such as doing that same check for every question — is an important part of thinking algorithmically.
An algorithm must have its steps in the correct order and each step must be precise. A computer does exactly what it is told, so an unclear or out-of-order step will produce the wrong output.
Putting the three together
The three principles are at their most powerful when combined. Suppose you want a program that finds the highest score in a class. Decomposition breaks the task into reading the scores, comparing them, and showing the result. Abstraction lets you ignore who sat where or when the test was taken — only the scores themselves matter. Algorithmic thinking gives you the ordered steps: treat the first score as the highest so far, then check each remaining score and replace the highest whenever you find a bigger one.
Watch out for these common misunderstandings:
- Abstraction is not the same as decomposition — abstraction removes detail, while decomposition breaks a problem into parts.
- An algorithm is the finished set of steps; algorithmic thinking is the process of working those steps out.
- Abstraction keeps the important detail — it does not simply mean ‘making things shorter’.
Master these three principles and you have the core toolkit of a computer scientist — a dependable way to take any problem, however large, and shape it into something a computer can solve.