Subjects and lessons to explore.

Law

Computer Science Fundamentals · Foundations

Computational Thinking

9 min read 5 practice questions
8 key termsSourcesReport an error
Want it in plain words first? Jump to Eli explains — the same idea, no jargon.
On this page 9 sections
  1. In 30 seconds
  2. Why this matters
  3. The college version
  4. Eli explains
  5. Worked example
  6. Key takeaway
  7. Quick check
  8. Study tools
  9. Sources & references

In 30 seconds

is a way of framing a problem so that a computer, or a person, can carry out the solution. It is a thinking skill, not coding itself. Most courses teach it through four pillars: (break the problem up), (spot what repeats), (keep only what matters), and (write ordered steps). Jeannette Wing popularized the term in a 2006 article, arguing it belongs alongside reading, writing, and arithmetic for everyone.

Why this matters

Almost every technical course asks you to turn a messy real-world problem into precise, solvable steps, and computational thinking is the skill that does it. It comes before any programming language: get the thinking right and the code is a translation; get it wrong and no syntax will save you. The four pillars give you a reusable checklist for problems in biology, business, writing, and daily life, not only computer science. Employers increasingly treat this structured problem-framing as a baseline literacy, which is exactly why Jeannette Wing argued it should be taught to every student, not just future programmers.

The college version

What computational thinking is (and is not)

Computational thinking is the thought process of formulating a problem so that its solution can be expressed as clear, ordered steps a computer or a person could actually carry out. The key word is formulating: the work happens before any code is written. Jeannette Wing brought the term to prominence in a 2006 Viewpoint in Communications of the ACM, where she argued that computational thinking 'builds on the power and limits of computing processes, whether they are executed by a human or by a machine.' Her central claim was ambitious: that computational thinking is 'a fundamental skill for everyone, not just for computer scientists,' and that alongside reading, writing, and arithmetic it belongs in every child's analytical toolkit. Note what this rules out. Computational thinking is not the same as programming. Programming is one way to express a solution in a language a machine runs; computational thinking is the reasoning that decides what the solution should be in the first place. You can think computationally with pencil and paper, and you can write code without thinking computationally at all.

The four pillars

Computer science education usually teaches computational thinking through four pillars. Decomposition means breaking a large, tangled problem into smaller sub-problems you can tackle one at a time. Pattern recognition means spotting similarities, trends, and repetition, both within a problem and across problems you have solved before, so you can reuse what already works. Abstraction means focusing on the details that matter for the task and deliberately ignoring the rest, which keeps the problem small enough to reason about. Algorithm design (also called algorithmic thinking) means expressing the solution as an ordered, unambiguous sequence of steps that someone or something can follow to get a reliable result. The four are not a strict pipeline; in practice you move between them, and abstraction in particular threads through all the others. Each of these pillars is a topic in its own right, so this lesson is the map that shows how they fit together rather than a deep dive into any one.

How the pillars work together

The pillars are most useful in combination, and each hands off to the next. Decomposition gives you a set of smaller problems; pattern recognition tells you which of those you have effectively solved before; abstraction strips each piece down to the information that actually drives the answer; and algorithm design stitches the pieces into a procedure you can execute or hand to a computer. Skipping a pillar tends to cost you later: no decomposition and the problem stays overwhelming; no abstraction and you drown in irrelevant detail; no clear and even a well-understood problem produces inconsistent results. Because the same four moves apply whether you are analyzing traffic-accident data, planning a budget, or organizing a research paper, the skill transfers far beyond computer science. That transferability is the whole point: computational thinking is a general method for turning 'this is complicated' into 'here are the steps.'

Beyond four neat boxes

The four-pillar breakdown is a teaching convention, not a law. It comes from computer-science education bodies such as ISTE and CSTA and from open textbooks, and it is genuinely useful for beginners. But Wing's original 2006 paper does not present a tidy four-item list. She described computational thinking as a much wider family of mental tools, including thinking recursively, separating concerns, choosing a good representation for a problem, and 'reformulating a seemingly difficult problem into one we know how to solve.' So treat the four pillars as a reliable starting frame, and remember that experienced problem-solvers draw on more moves than four. The honest summary is that computational thinking is a broad problem-framing habit, and the four pillars are the most widely taught doorway into it.

Eli, the EliExplains learning guide

Eli explains

The same idea, in plain words

Explain it like I’m 10

Computational thinking is a way of getting ready to solve a big, messy problem before you actually do anything. First you chop the big problem into small pieces so none of them feels scary. Then you look for pieces that are like ones you have handled before, so you do not start from zero. Then you decide what really matters and ignore the stuff that does not, so you are not distracted. Finally you write down the steps in order, like a recipe, so you (or a computer) can follow them without guessing. Notice that none of this is typing code. It is planning. The code, if there is any, comes after the thinking is done.

Picture it like this

It is like packing for a trip. You split packing into piles (clothes, toiletries, chargers), you reuse your usual packing list because trips repeat, you pack only what this trip needs and leave the rest home, and you follow an order so nothing gets forgotten. That is decomposition, pattern recognition, abstraction, and a step-by-step plan.

Where the picture stops working

Packing is a one-off chore with a fixed goal, while computational thinking often aims at problems that must be re-solved for many different inputs, and it cares about whether the steps are correct and efficient, not just whether the suitcase closes. Real problems also loop back, so you may re-decompose after you spot a pattern rather than moving through the piles once.

Worked example

Problem: run a Saturday of errands as efficiently as possible. Decomposition: split it into sub-tasks, drop off library books, buy groceries, pick up a prescription, get gas. Pattern recognition: you notice this is the same 'visit several stops, minimize driving' problem you solved last month, and that the pharmacy and grocery store sit in the same plaza, a recurring cluster. Abstraction: for routing you keep only each stop's location and open hours and ignore irrelevant details like a store's paint color or aisle layout. Algorithm design: you produce ordered steps, (1) leave home, (2) library, since it opens earliest, (3) the shared plaza for pharmacy then groceries, (4) gas on the way home, (5) return. All four pillars, and not one line of code.

Key takeaway

Computational thinking is the skill of framing a problem so it can be solved by ordered steps, taught through four pillars, decomposition, pattern recognition, abstraction, and algorithm design, and it is a way of thinking for everyone, not the act of coding.

Quick check

3 questions here, of 5 in this lesson’s practice set. Answers stay hidden until you check.

Question 1 of 3foundational

Who popularized the term 'computational thinking,' and where?

Choose an answer, then check it.
Question 2 of 3foundational

Which of the following is NOT one of the four widely-taught pillars of computational thinking?

Choose an answer, then check it.
Question 3 of 3intermediate

A student turns 'plan the class trip' into four separate sub-tasks: transport, tickets, food, and permission slips. Which pillar is this?

Choose an answer, then check it.
Practice all 5

Keep learning

Ready to build on this? Continue to the next lesson.

Practice this lesson
Study tools & related lessonsYou’ll learn to · Common mistakes · Easily confused · Key vocabulary · Related

You’ll learn to

  • Define computational thinking as a problem-framing skill distinct from coding.
  • Attribute the term's popularization to Jeannette Wing (2006, Communications of the ACM).
  • Explain the four widely-taught pillars: decomposition, pattern recognition, abstraction, and algorithm design.
  • Apply all four pillars to a concrete everyday problem.
  • Distinguish the tidy four-pillar teaching framing from Wing's broader original vision.

Common mistakes

  • Treating computational thinking as a synonym for coding or programming.

    It is the problem-framing that comes before code. You can think computationally on paper, and code is just one way to express the resulting steps.

  • Believing Jeannette Wing defined exactly four pillars.

    The four pillars are a later CS-education teaching frame (ISTE/CSTA, OER texts). Wing's 2006 paper describes a broader set of tools, including recursion, separation of concerns, and choosing good representations.

  • Confusing abstraction with decomposition.

    Decomposition splits a problem into smaller parts; abstraction removes irrelevant detail from a part so you can focus on what matters. You often do both, but they are different moves.

  • Thinking computational thinking only applies inside computer science.

    Wing and bodies like ISTE frame it as a general analytical skill useful across subjects and everyday life, from budgeting to data analysis to planning.

  • Assuming the pillars must be done once, in a fixed order.

    In real problem-solving you move back and forth, for example re-decomposing after spotting a pattern; the pillars are cooperating moves, not a rigid pipeline.

Easily confused

Computational thinking vs. Programming

Computational thinking is deciding what the solution should be and framing it as clear steps; programming is expressing those steps in a language a machine can run. The first can happen with no computer at all.

Decomposition vs. Abstraction

Decomposition breaks a whole into smaller sub-problems; abstraction strips a problem down to only its relevant details. One reduces size, the other reduces detail.

Wing's original vision vs. The four-pillar teaching frame

Wing (2006) described a broad family of mental tools; the four pillars are a simplified, widely-taught doorway to that vision, not a verbatim list from her paper.

Key vocabulary

Computational thinking
The thought process of framing a problem so its solution can be expressed as clear, ordered steps that a person or a computer can carry out.
Decomposition
Breaking a large or complex problem into smaller sub-problems that can be understood and solved one at a time.
Pattern recognition
Identifying similarities, trends, and repetition within a problem or across problems so existing solutions can be reused.
Abstraction
Keeping only the details that matter for the task at hand and deliberately ignoring the rest to make a problem manageable.
Algorithm design
Expressing a solution as an ordered, unambiguous sequence of steps that reliably produces the intended result; also called algorithmic thinking.
Algorithm
A finite, ordered set of unambiguous instructions for solving a problem or completing a task.
Problem formulation
Stating a problem precisely enough that a solution method can be designed for it; the core activity of computational thinking.
Pillar (of computational thinking)
One of the four commonly taught components of computational thinking: decomposition, pattern recognition, abstraction, or algorithm design.

Sources & references

  1. Computational Thinking (Viewpoint) — Jeannette M. Wing, Communications of the ACM, Vol. 49, No. 3
  2. Introduction to Computer Science, Section 2.1: Computational Thinking — OpenStax (Rice University)
  3. Computational Thinking Competencies — International Society for Technology in Education (ISTE)

EliExplains lessons are original prose written from the open, credible references above. See Copyright & Licensing.

Researched 2026-08-19

Educational content only. It is not medical, legal or professional advice. Found an error? Tell us.