Computational thinking (CT) is often described as a set of problem-solving practices that enable people to express problems and solutions in a manner that a computer can execute. It’s commonly framed as the thought process that precedes coding and programming.
That definition is useful, but incomplete.
Over time, I’ve come to see computational thinking less as preparation for computers and more as a way of reasoning carefully in complex systems, especially when there is no perfect solution.
CT is not just about getting computers to do jobs for people. It’s about how people decide what jobs should be done, under what constraints, and with what consequences.
What is Computational Thinking?
CT can have multiple meanings for various populations. CT is essential to programming, but it can be used to facilitate problem-solving across all disciplines.
It shows up anywhere people must:
- Break down messy problems
- Decide what matters and what doesn’t
- Anticipate edge cases
- Make tradeoffs explicit
- Take responsibility for imperfect choices
In other words, CT is a way of thinking that helps us design systems and live with them.
This is why CT matters far beyond the realm of computer science.
Core Elements of Computational Thinking
Many educators are familiar with the framework popularized by Google’s Computational Thinking for Educators course:
- Decomposition
- Pattern Recognition
- Abstraction
- Algorithm Design
These elements don’t follow a strict order, and they don’t require coding to be meaningful. They describe how people think when they are trying to make sense of complex situations.
PRADA: A Practical Way to Think About CT
We can reorder the elements into PRADA as a mnemonic device to help remember the terms.
Pattern Recognition
Observing patterns, trends, and similarities across data, processes, or situations.
This helps us recognize what repeats, and what doesn’t, so we don’t treat every problem as entirely new.
Abstraction
Deciding what details matter right now and which ones can be temporarily set aside.
Abstraction isn’t about ignoring complexity. It’s about managing it.
Decomposition
Breaking a problem into smaller, more manageable parts.
This allows us to reason about one piece at a time without losing sight of the whole.
Algorithms
Designing step-by-step processes for solving problems, or at least moving them forward.
Algorithms don’t have to be code. They can be workflows, routines, or decision sequences.
On Thinking Algorithmically
It’s important to note that computational thinking isn’t about finding the “right” answer. Even though it is about problem-solving behaviors, it’s about making your reasoning visible and revisable.
In practice, this often means:
- Naming constraints instead of pretending they don’t exist
- Bounding risk rather than trying to eliminate it entirely
- Choosing tradeoffs you are willing to be accountable for
This kind of thinking appears in decisions that might seem mundane, or decidedly non-technical, like:
- Which platforms to use
- How data flows through those systems
- Who controls access
- What happens when something goes wrong
Even when no code is written, these are computational questions.
Why This Matters for Teaching and Learning
When CT is taught only as preparation for coding, we undersell its real power. When we teach it as a way to:
- Think ethically about systems
- Reason under uncertainty
- Design with care and responsibility
…we equip students and educators with tools that transfer to every part of life.
That’s the version of CT I’m trying to model. Thinking out loud, documenting decisions, and inviting critique. In my posts, I explore how these practices show up in everyday decisions. At home, in classrooms, and in the digital systems we rely on.