Computational Thinking

KS3 Computer Science

11-14 Years Old

48 modules covering EVERY Computer Science topic needed for KS3 level.

GCSE Computer Science

14-16 Years Old

45 modules covering EVERY Computer Science topic needed for GCSE level.

A-Level Computer Science

16-18 Years Old

66 modules covering EVERY Computer Science topic needed for A-Level.

GCSE Computational Thinking (14-16 years)

  • An editable PowerPoint lesson presentation
  • Editable revision handouts
  • A glossary which covers the key terminologies of the module
  • Topic mindmaps for visualising the key concepts
  • Printable flashcards to help students engage active recall and confidence-based repetition
  • A quiz with accompanying answer key to test knowledge and understanding of the module

A-Level Computational thinking (16-18 years)

  • An editable PowerPoint lesson presentation
  • Editable revision handouts
  • A glossary which covers the key terminologies of the module
  • Topic mindmaps for visualising the key concepts
  • Printable flashcards to help students engage active recall and confidence-based repetition
  • A quiz with accompanying answer key to test knowledge and understanding of the module

We may think that computers “think” and that they outsmart humans “just like that”. However that’s not the case, computers do exactly what we humans tell them to do, or better said, what we program them to do. Once programmed a computer can only execute problems and produce solutions more efficiently than humans.

Computational thinking dates back to the 1950s, although most of the ideas it was based upon date further back.

Computational thinking incorporates characteristics such as abstraction, logically organising data, and data representation, which can also be found in other types of thinking such as: scientific thinking, engineering thinking, design thinking, model-based thinking, and systems thinking.

The term “computational thinking” was first used in 1980 by Seymour Papert, who was one of the pioneers of artificial intelligence.

However, the term wasn’t used as much until 2006, when computer scientist Jeannette Wing’s article in “Communications of ACM” mentioned it.

She said the following:

“Computational thinking is a fundamental skill for everyone, not just for computer scientists. From reading, writing, and arithmetic, we should add computational thinking to every child’s analytical ability”, and since then, educators have been trying to incorporate computational thinking more and more in classrooms with kids of young age.

So, therefore, computational thinking has become a popular phrase that refers to a collection of computational ideas and habits of mind that people in computing and non-computing disciplines acquire through their work, and even possibly their everyday life.

What is Computational Thinking?

Computational thinking is the process, which is involved in formulating a problem as well as expressing its solution(s) that both humans and computers can comprehend and execute.

Computational thinking enables the user to work out exactly what to tell a computer system.

It describes the mental activity in formulating a problem to admit a computational solution, furthermore, this solution can either be carried out a by a human or a machine.

The theory of computational thinking doesn’t just revolve around problem-solving, it also involves problem formulation.

Concepts of Computational Thinking:

There are four principles of computational thinking, they are:

  • Decomposition
  • Pattern recognition
  • Abstraction
  • Algorithm design


Decomposition is the breakdown of a complex problem into smaller less complex parts. These problems will be solved one after another until the bigger problem is solved.

Decomposition is important because dealing with many different steps separately rather than solving one big issue can allow for a more speedy and open-minded solution(s), furthermore, it can also increase efficiency, and can make developers look at a problem in a more detailed way.

For instance, seeing how a bike works when it is deconstructed into smaller parts is more straightforward than having the whole bike in front of you and explaining what each part does.

Pattern Recognition:

Once the problem is decomposed into smaller less complex parts, step number two would be to see what similarities the problems share.

These similarities that each individual problems share will allow developers to create a solution that will be applicable for many problems. Pattern recognition will allow developers to solve problems more efficiently as they can apply what they already have developed an answer to, to a new similar problem.


Abstraction refers to focusing on the relevant and most important information only, ignoring any details which will not aid the development. Ignoring irrelevant characteristics is beneficial to reaching the desired solution.

In abstraction, the general characteristics that are common to each element inside of specific details are focused on.

Once the general characteristics are collated, a model of the problem can be developed, which can then be used to develop an algorithm. 

Abstraction is important as it allows developers to create a general idea of what the problem is and how to solve it, which ultimately allows the developers to form an idea of the problem, this is referred to as the model.

If abstraction is not done, the problem could lead the team to the wrong solution.

Algorithm Design:

An algorithm can be defined as a plan, which includes a series of subsequent steps to solve a problem, thus executing a program.

In an algorithm, every instruction must be identified and every instruction must have a place in a sequence of instructions, so it can be executed.

Once the above steps have been completed, the next step is to develop a step-by-step set of instructions to solve each of the smaller problems.

These simple steps/rules are the set of instructions to help solve complex problems in the most efficient way.

Computers and computer systems are functionally and performance dependent on the algorithms in which they execute.

Algorithms are used in many different aspects ranging from calculations, automation, and data processing.

Once an algorithm is written the below checklist must be checked:

  1. It is easily understood, and fully decomposed
  2. Solves every aspect of the problem
  3. Efficient
  4. Meets any design criteria given

Though developing these algorithms isn’t easy, below is a brief way on how they can be initiated (thought about):


A flowchart is a type of digraph that represent how the algorithm will function, workflow or process, furthermore, a flowchart represent a solution model to a given problem.

Algorithms are more easily developed by programmers with the use of flowcharts.

Flowchart example:Computational Thinking Image 1

Flowchart example of Computational Thinking.

Flowchart advantages

  • Communication:
    • Flowcharts are a good way to portray the logic of a system.
  • Effective Analysis:
    • A problem can be analysed more efficiently using a flowchart.
  • Proper documentation:
    • Flowcharts serve as a good program documentation.
  • Efficient coding:
    • Flowcharts are useful when developing the program as they set out for the developer a clear cut idea of what they need to do, and what order they must do it in.
  • Proper debugging:
    • Flowcharts aid debugging and the testing process.
  • Efficient program maintenance:
    • The maintenance of operating programs become simplified as the connecting peripherals are known, this increases efficiency as the developer doesn’t require to begin from the beginning.

Flowchart disadvantages

  • Complex logic:
  • Flowcharts are useful for simple solutions and systems, however they become very complex to follow for large complicated solutions/systems.
  • Alternations and Modifications:
  • Any modifications/changes, which are required to be done on a system, that need to be represented on the flowchart would result in a new flowchart being created.


When learning to code, you’re teach/tutor or whoever is teaching you to code (even if you are self learning) will tell you to write pseudocode.

Pseudocode is writing the code which you will execute, though in English (or whatever language you use). This pseudocode will help you collate the findings, ideas, and even solutions, which may be plausible into a block of English, then it’ll be transformed into code so the computer can understand it.

Pseudocode aids a developer to plan the solution and more importantly it will help in avoiding mistakes, or decrease them, which inevitably means that you utilise your time more efficiently.

As mentioned above, Pseudocode is written in i.e. English, so it doesn’t use the syntax that programming languages use, however it does use the keywords and variables that you will use when you eventually code the solution, it can be considered to be a simplified way that reads like code.

An example is shared below:

Pseudo code:

If balance < 0

display message “the balance is negative”


display message “the balance is greater than zero, your balance is okay”

Python code:

if balance < 0:

print(‘balance is negative’)


print(‘the balance is greater than zero, your balance is okay’)

Pseudocode advantages

  • Language independent:
    • Allow developers to express the design in plain and natural language (whatever language they want)
  • Easier to use than a flowchart:
    • Programmers only have to think about the underlining logic when writing pseudocode. Pseudocode focuses on the steps to solving the problem rather than how to use the computer language.
  • Doesn’t require experience:
    • Writing pseudocode can be done by a highly experienced programmer as-well as a programmer who just started developing. There is no experience required in writing pseudocode.
  • Simple Translation:
    • The use of phrases and general words in pseudocode allows for easier translation into code, which a computer can comprehend.
  • Simple Structure
    • Pseudocode has a simple structure and can be easily modified unlike flowcharts.

Pseudocode disadvantages

  • No visual representation:
    • There is no visual representation of the programme logic.
  • No standard of written style:
    • There isn’t one specific way of writing pseudocode, meaning there is no standard to abide by. Programmers can write it however they wish. Which means other programmers may find it difficult to read it if they’re not familiar with the problem which is being solved.

Evaluating Solutions

Despite doing the steps above, the final solution must be evaluated, meaning the programmers must make sure that the program designed satisfies the problem, and that it does it efficiently too.

Evaluation is considered to be the process that allows developers to make sure that the solution developed executes properly and does the job it was designed to do, furthermore, the user must also think about how it could be improved. A failure to properly evaluate would result in difficulties to execute the program solution.

Why is computational thinking important in a workplace?

Many of today’s businesses are about business solving, it can range from developing breakthrough products and services for customers or enhancing/increasing the efficiency of already developed businesses.

Even though businesses might not require programming to function, the business itself requires individuals to be able to understand and think through business problems using the computational thinking concepts mentioned above.

Therefore computational thinking to any business sector or public service can be applied.

For instance, designing the user journey for a retail e-commerce site involves being able to break a problem into parts, which is decomposition, and then being able to solve the issue using a sequence of steps is considered to be algorithmic thinking, another example is planning and forecasting, which can be classified as patterns of abstraction.

Therefore, this shows us that, we use “computational thinking” without thinking that we use it, even in our everyday life and workplaces.

Risks with Computational thinking

Lack of ambition:

  • A lack of historical insight and ambition will lead to a lack of “rein-venting the wheel”, which may lead the computational thinking initiatives to become watered down versions of their 1980’s predecessors.
  • Computational thinking initiatives which only focus on programming tools and techniques are marketing a bland view of computing which emphasises analytical abstract world which is far from the real complexities of the real world.
  • Computational thinking is no longer a means of adding new statements and facts to the knowledge of the computing body.
  • It is now a means that aims for insight, understanding, productive practice, as-well as wisdom.


  • Dogmatism refers to the tendency to lay down principles as undeniably true, without considering any opinions or evidence to match those principles.
  • Educators should not claim that computational thinking is the “best” method of thinking and best way for problem solving. Many other kinds of “thinking” such as engineering thinking, science thinking, logical thinking, systems thinking, network thinking, rational thinking design thinking, ethical thinking, critical thinking and many more can also be considered.
  • Our only type of thinking shouldn’t be limited to computational thinking, and we should diversify it.

Knowing Verses Doing:

  • There is an increasing notion that computational thinking is a skill rather than a particular set of applicable knowledge which is surprisingly light on what constitutes the skill or how to asses it.
  • A skill is a characteristic or an ability, which is acquired over time and experience, it’s not knowledge of facts or information. 

Exaggerated Claims:

  • Although the evidence suggests to the contrary that computational thinking confers problem solving skills, which are transferable to non-computational knowledge domains, still arise.
  • A lack of historical insight may allow for the same mistakes to be repeated once again.

Narrow Views of Computing:

  • There are some critics, which claim that computational thinking is programming in disguise. One particular risk arises if, “coding is accepted as the aim of computational thinking”, and this risk may get confused with the definition of “coding”.
  • Coding is just a single part of a program construction and isn’t the part which requires the most computational thinking, furthermore many key concepts of coding such as selection and iteration are not central to computational thinking.

Losing Sight of Computational Models:

  • Computational thinking should be also thought about in the designing of new models rather than control of existing models.
  • The computational model initiatives should always consider the strong bond between computational thinking and the behaviour of machines, whether that is practical or theoretical, because if this insight is lost, this may risk exaggerated claims of applicability of computational thinking.

Summary and Facts

Computational thinking allows the user to work out exactly what to tell the computer to do because a computer only acts and processes what it is programmed to do. Once the computer system understands the problem, only then they can solve problems more efficiently than humans with their fast processing power.

Computational thinking is the process, which is involved in formulating a problem as well as expressing its solution(s), that both humans and computers can comprehend and execute.

Computers and computer systems are functionally and performance dependent on the algorithms in which they execute.

Algorithms are used in many different aspects ranging from calculations, automation, and

data processing.

When planning to solve a solution, it is important to make a plan which is feasible for the problem which is being solved, therefore using computational thinking strategies (decomposition, pattern recognition, abstraction, and algorithms) developers can break down a problem and filter out any information which isn’t needed and develop patterns which they can see are relevant. Developers must develop an algorithm, which is required to solve the problem. 

The algorithm must have a starting point and an ending point, furthermore it must have clear non-ambiguous instructions in between.

Lastly developers must evaluate a solution that they had developed and make sure that it fits the criteria of the given circumstances.

One of the best ways to test a solution is through “dry runs”, developers can work through the program solution and trace a path through it. If the program doesn’t provide the correct output, then it’ll need fixing, and recording the path through the algorithm will help showcase the error when debugging.

Whether or not a business involves programming, businesses find it beneficial that their employee’s think in a computational manner to resolve problems efficiently.

Concepts of Computational Thinking:

  • Decomposition:
    • Decomposition involves the process of breaking down complex problems into smaller, achievable parts.
  • Pattern Recognition:
    • Pattern recognition involves the excavation for similarities within and among the problem.
  • Abstraction:
    • Abstraction will focus on the important information available, ignoring any irrelevant data.
  • Algorithms: 
    • Algorithms are referred to as the “solution” or “executable”, as the algorithms will be the step-by-step solution, which will solve the problem.

Once the steps above are complete, the given solution must be evaluated.

Flowchart advantages:

  • Communication
  • Effective Analysis
  • Proper documentation
  • Efficient coding
  • Proper debugging
  • Efficient Program maintenance 

Flowchart disadvantages:

  • Complex logic
  • Alternations and Modifications

Pseudocode advantages:

  • Language independent
  • Easier to use than a flowchart
  • Doesn’t require experience
  • Simple Translation
  • Simple Structure

Pseudocode disadvantages:

  • No visual representation
  • No standard of written style

Risks with Computational thinking:

  • Lack of ambition
  • Dogmatism
  • Knowing Verses Doing
  • Exaggerated Claims
  • Narrow Views of Computing
  • Losing Sight of Computational Models