Computational Thinking is a collection of different problem-solving skills based on the skills needed to be a programmer. However, these skills are not only useful in programming, they are also applicable outside of computer science.
The six problem-solving skills we work with in the project, based on a compilation by Bocconi et al. (2016), are:
For a better explanation, we use an everyday example here to describe the individual capabilities.
Algorithmic Thinking:
A recipe for making soup is, at its core, nothing more than an algorithm – a step-by-step guide to achieving a goal. Algorithmic thinking is needed when we want to create a recipe on our own.
Decomposition:
When creating the recipe, it is necessary to break down the big problem into smaller ones. For example, we could first ask ourselves what ingredients we want to use in the first place, and then think about the individual ways of preparing the vegetables.
Automation:
Cutting up vegetables and stirring soup are tasks that are repetitive and require little human input. Instead, the task can be handed over to a machine.
Debugging:
The ability to “debug” involves two different starting points of the process:
- On the one hand, it is the ability that if the result is incorrect (for example, a soup that does not taste good), we can find the error and correct it.
- On the other hand, it is also the ability that we can detect errors even before the execution of the recipe and also correct it.
Generalization:
A solution that works for a certain problem can be extended in some situations so that it works for a whole class of similar problems. To stay with the soup example: Once we know how soup works, we can adopt a similar approach for other types of soup.
Abstraction:
Recognizing patterns in more complex processes and abstracting them to the essentials has always been one of the most important human skills in solving problems. This ability to focus on the core logic instead of being overwhelmed by every technical detail is crucial in programming. However, we also encounter many abstractions in the analog world. For example, a formally written recipe for cooking a soup can often be further abstracted and presented, for example, in the form of a flowchart that only depicts the core logic and omits all unnecessary details.