Exam Board:
OCR A-Level
Specification:
Computer Science H446
1.1 - Computational Thinking
Watch on YouTube:
Thinking Abstractly
Thinking Ahead
Thinking Procedurally
Thinking Logically
Thinking Concurrently
Computational thinking is the process of approaching and solving problems in a logical, systematic way (like a computer would) using techniques such as abstraction, decomposition, pattern recognition and algorithmic thinking. There are five categories of computational thinking you need to know.
Thinking Abstractly
Abstraction is the process of removing unnecessary detail so that a problem can be represented more simply. It helps programmers focus on the essential features of a task, reducing complexity and making solutions easier to design, understand and maintain.
When programming, abstraction can be applied by simplifying real-world systems into models that contain only the information needed for solving the problem. Because abstractions leave out certain details, they always differ from reality, and it is important to understand which elements have been included, which have been excluded and why.
Thinking Ahead
Programs often make use of inputs and outputs to receive data from the user or another system and then return results or feedback. Many programs rely on preconditions - rules or requirements that must be met before a function or procedure runs correctly - to prevent errors and ensure reliable behaviour.
Caching is a technique where previously calculated or frequently accessed data is stored temporarily so it can be retrieved more quickly. This improves performance but can use extra memory and risks becoming outdated if the cached data no longer matches the current state.
Reusable program components, such as functions, procedures and modules, are important because they reduce duplication, make programs easier to maintain, and allow well-tested code to be used across multiple solutions.
Thinking Procedurally
Pseudocode, program code and flowcharts are ways of representing a sequence of steps in an algorithm, showing clearly the order in which instructions should be carried out.
Sub-procedures (such as functions and procedures) are used in programs to break complex tasks into smaller, reusable parts, making the code easier to understand, test, maintain and debug.
A structure diagram is a visual representation that shows how a program is broken down into its main components and sub-components, helping programmers plan the overall design and understand how different parts of the program fit together.
Thinking Logically
Decisions are needed in computer programs so that the software can choose different actions based on the data it receives or the situation it is in, rather than always following the same sequence of instructions.
These decisions are controlled by logical conditions - statements that evaluate to true or false - which determine which path the program will take; for example, if score > 100 might trigger a bonus feature only when the condition is true.
Because decisions allow the program to branch, they directly affect the flow of execution, enabling different outcomes, repeated actions or alternative processes depending on the conditions met.
Thinking Concurrently
Concurrency means designing a program so that multiple tasks can be processed at the same time, rather than strictly one after another.
Programmers need to identify which parts of a program can safely run concurrently - for example, independent calculations or background tasks - and which parts must wait for others to finish because they rely on shared data or sequential results.
Concurrent processing can bring benefits such as faster performance, better use of multicore processors and improved responsiveness, but it also introduces drawbacks, including increased complexity and the need for careful coordination to avoid errors when tasks depend on one another.
Questo's Key Terms
Computational Thinking: abstraction, thinking abstractly, thinking ahead, precondition, caching, reusable components, thinking procedurally, thinking logically, concurrency, thinking concurrently
Did You Know?
Building a Lego set is a great example of both abstraction and decompostition. For example, the Eiffel Tower Lego set is an abstracted version of it is real-life counterpart condensed into 10,001 pieces. There are over 75 numbered bags inside the box to follow instructions step-by-step to construct the 4'11" model.
