Computational Thinking Defined (2024)

Computer science is the study of computational processes and information processes. Information is the result of processing data by putting it in a particular context to reveal its meaning. Data are the raw facts or observations of nature and computation is the manipulation of data by some systematic procedure carried out by some computing agent.

Computational problems, in general, require a certain mode of approach or way of thinking. This approach is often called computational thinking and is similar, in many ways, to the scientific method where we’re concerned with making predictions.

Computational Thinking Steps: In order to make predictions using computational thinking, we need to define three steps related to the problem and its solution:

1. Problem Specification: We start by analyzing the problem, stating it precisely, and establishing the criteria for the solution. A computational thinking approach to a solution often starts by breaking complex problems down into more familiar or manageable sub-problems, sometimes called problem decomposition, frequently using deductive or probabilistic reasoning. This can also involve the ideas of abstraction and pattern recognition. More formally, we’d use these techniques in creating models and simulations.
2. Algorithmic Expression: We then need to find an algorithm, a precise sequence of steps, that solves the problem using appropriate data representations. This process uses inductive thinking and is needed for transferring a particular problem to a larger class of similar problems. This step is also sometimes called algorithmic thinking. We can further break it down into either imperative, like procedural or modular, and declarative, like functional, approaches to algorithmic solutions.
3. Solution Implementation & Evaluation: Finally, we create the actual solution and systematically evaluate it to determine its correctness and efficiency. This step also involves seeing if the solution can be generalized via automation or extension to other kinds of problems.

I should add a little caveat here: these rules for computational thinking are all well and good but they’re not really rules, per se; instead, think of them more like well-intentioned heuristics, or rules of thumb.

These heuristics for computational thinking are very similar to the heuristics usually given for the 5-step scientific method taught in grade school, which is often written out as something like:

1. Observe some aspect of the universe
2. Use those observations to inform some hypothesis about it
3. Make some prediction using that hypothesis
4. Test the prediction via experimentation and modify the hypothesis accordingly
5. Repeat steps 3 and 4 until the hypothesis no longer needs modification

These are nice guidelines but they’re not mandatory. They’re suggestions of ideas you’ll likely need or require for most efforts but it’s not some process to pigeonhole your thinking or approach to a solution.

At its core, the central aspect of all fundamental physical science is prediction, usually through experimentation. If you’re able to make repeated, precise, quantitative predictions, it implies that whichever model you’ve used or whichever mode of thinking you’ve employed, it’s actually working and should likely be re-employed. If it’s a formal method, great; if it’s something less formal, yet still structured and repeatable and leads to correct computational solutions, that’s also fine.

Any structured thinking process or approach that lets you get to this state would be considered computational thinking. You can even think of it as an alternative definition of critical thinking or evidence-based reasoning where your solutions result from the data and how you think about that data:

Data + How to Think about that Data = Computational Thinking

In this sense, being able to represent the data and then manipulate it is itself a computational solution to a computable problem!

We can then think of programs as being the computational solutions, the solutions to computable functions, that we express in some particular programming language. We also know that an algorithm is an effective procedure, a sequence of step-by-step instructions for solving a specific kind of problem using particular data structures, which designate specific data representations.

But before we implement our solution in a particular programming language, we have to define an algorithmic solution for the problem we’re examining. Let’s look at how to actually find such a computational solution with the caveat that individual steps will be customized as different problems will require different detailed approaches.

Computational Thinking Steps

As we saw above, Computational Thinking is an iterative process composed of three stages:

1. Problem Specification: analyze the problem and state it precisely, using abstraction, decomposition, and pattern recognition as well as establishing the criteria for solution
2. Algorithmic Expression: find a computational solution using appropriate data representations and algorithm design
3. Solution Implementation & Evaluation: implement the solution and conduct systematic testing before generalizing to other problems

Details of the Computational Thinking Approach

Let’s list the details of the five computational thinking principles and the accompanying computer science ideas and software engineering techniques that can come into play for each of these three steps. Please note, this is not a comprehensive listing but is representative.

In this approach, we can also think of the Principles as the Strategy, the high level concepts needed to find a computational solution; the Ideas can then be seen as the particular Tactics, the patterns or methods that are known to work in many different settings; and, finally, the Techniques as the Tools that can be used in specific situations. All of these are needed to come up with the eventual computational solution to the problem.

1. Problem Specification

• Computational Thinking Principles: Model Development with Abstraction, Decomposition, and Pattern Recognition
• Computer Science Ideas: Problem Analysis and Specification
• Software Engineering Techniques: Problem Requirements Document, Problem Specifications Document, UML diagrams, etc.

2. Algorithmic Expression

• Computational Thinking Principles: Computational Problem Solving using Data Representation and Algorithmic Design
• Computer Science Ideas: Data representation via some symbolic system and algorithmic development to systematically process information using modularity, flow control (including sequential, selection, and iteration), recursion, encapsulation, and parallel computing
• Software Engineering Techniques: Flowcharts, Pseudocode, Data Flow Diagrams, State Diagrams, Class-responsibility-collaboration (CRC) cards for Class Diagrams, Use Cases for Sequence Diagrams, etc.

3. Solution Implementation & Evaluation

• Computational Thinking Principles: Systematic Testing and Generalization
• Computer Science Ideas: Algorithm implementation with analysis of efficiency and performance constraints, debugging, testing for error detection, evaluation metrics to measure correctness of solution, and extending the computational solution to other kinds of problems
• Software Engineering Techniques: Implementation in a Programming Language, Code Reviews, Refactoring, Test Suites using a tool like JUnit for Unit and System Testing, Quality Assurance (QA), etc.

Computational Thinking Principles

The first step of the computational solution, Problem Specification, relies upon some essential computational thinking principles. Although computational thinking isn’t a formal methodology for reasoning, it does encompass some basic principles that are useful in all fields and disciplines.

They constitute a way of reasoning or thinking logically and methodically about solving any problem in any area! These essential principles are also the buzzwords you can put on your résumé or CV so let’s first delve into an intuitive understanding of the more important ones, especially decomposition, pattern recognition, and abstraction, as well as its cousin, generalization.

Decomposition is simply the idea that you’ll likely break a complex problem down into more manageable pieces. If the problem is some complex task, you might break it down into a sequence of simpler sub-tasks. If the problem deals with a complex system, you might break the system down into a bunch of smaller sub-components. For example, if you’re faced with writing a large, complex paper, you might choose to tackle it by decomposing the paper into smaller sub-sections and tackling each of those separately.

Pattern recognition is the idea of spotting similarities or trends or regularities of some sort in a problem or some dataset. These patterns that we might identify help us make predictions or find solutions outright. For example, if you’re driving on the freeway and you notice cars bunching together in the left lane down the road, you might decide to change into the right lane. Or if you see a consistent trend upward in a stock for a number of months, you might decide to buy some shares in that stock. Disclaimer: correlation does not equal causation; even if you spot a pattern, you might want to confirm or validate that prediction with other analyses before actually putting your money where your pattern is.

Abstraction is the idea, as alluded to earlier, of ignoring what you deem to be unessential details. It allows us to thus prioritize information about the system under examination. We can use this idea of abstraction to do things like make models, such as the map to represent the campus mentioned before. Another example of abstraction might be creating a summary of a book or movie. We can also generalize to form a “big picture” that ignores some of the inessential details.

Generalization like this allows us to identify characteristics that are common across seemingly disparate models, thus allowing us to adapt a solution from one domain to a supposedly unrelated domain. Generalization can help us to organize ideas or components, as we do when we classify some animals as vertebrates and others as invertebrates. In addition, being able to identify the general principles that underly the patterns we’ve identified allows us to generalize patterns and trends into rules. These rules, in turn, can directly inform the final algorithm we’ll use in the second step of constructing the computational solution.

Algorithmic Expression: Computational Problem Solving

The second step of the computational solution, Algorithmic Expression, is the heart of computational problem solving. The conversion of Data to Information and then Knowledge can be done via computational problem solving. After defining the problem precisely, it involves these three steps:

• Data: structure raw facts for evidence-based reasoning
• Representation: create a problem abstraction that captures the relevant aspects of the system
• Algorithm: delineate a systematic procedure that solves the problem in a finite amount of time

Computational problem solving thus involves finding an appropriate representation of, or context for, the data, and using that representation in an algorithmic, step-by-step procedure that solves the problem once the problem is clearly defined.

The contextualization of data can be considered a first approximation of information and the solution transforms the data to information and then actionable knowledge. This can be seen further here.

One way to think about information is data in some context. If that context is the probability of occurrence, we end up with Shannon’s Information measure. If we put data in the context of some logic-based reasoning structure, we can reach some conclusion based on the evidence; this conclusion becomes our usable information that can form the basis of actionable knowledge. We can also codify this information in some knowledge-based system that is curated using knowledge management techniques.

Read more about Shannon’s Information Theory and Computational Thinking in my new book, also publicly viewable on ResearchGate.