Computational Thinking

Computer science is not only a collection of technologies.

It is also a way of structuring problems.

Computational thinking is the habit of transforming messy situations into forms that can be:

• represented,
• analyzed,
• automated,
• solved systematically.

It is broader than programming.

A Way of Seeing Problems

A programmer looks at a large task and asks:

• What are the parts?
• What information matters?
• What patterns repeat?
• Which steps can be formalized?
• Which parts require judgment?

These questions are computational even before code is written.

Decomposition

A difficult problem is often too large to solve directly.

Decomposition breaks it into smaller parts.

For example, building a search engine involves:

• crawling,
• indexing,
• ranking,
• querying,
• user interface.

Each subproblem can be studied separately.

Why Decomposition Works

Complex systems exceed working memory.

Breaking a problem into components reduces cognitive load.

It also creates interfaces.

Each component can expose:

• inputs,
• outputs,
• guarantees.

Modularity begins here.

But Decomposition Is Not Neutral

How we divide a problem matters.

A poor decomposition creates:

• excessive dependencies,
• duplicated work,
• unclear boundaries.

Good decomposition reveals natural structure.

Pattern Recognition

Once a problem is decomposed, repeated structures often appear.

A programmer may notice:

• the same validation logic,
• the same traversal pattern,
• the same state transition.

Recognizing recurrence allows reuse.

Generalization

Suppose we write code for:

• sorting students by score,
• sorting books by title,
• sorting files by size.

These are instances of one general operation:

sorting items under a comparison rule.

Generalization replaces many special cases with one abstraction.

Abstraction

Abstraction keeps relevant structure and hides irrelevant detail.

A graph abstraction may ignore:

• road width,
• building color,
• terrain.

It keeps:

• nodes,
• edges,
• weights.

This simplification makes algorithms possible.

Abstraction Is Lossy on Purpose

An abstraction discards information.

That is not a flaw.

It is the point.

The challenge is deciding what can be safely ignored.

The Wrong Abstraction

Suppose we model a transportation network only by distance.

We may miss:

• travel time,
• tolls,
• capacity,
• one-way restrictions.

An abstraction is useful only relative to a question.

Representation

A problem becomes computationally tractable when represented appropriately.

Consider social relationships.

Represent them as a graph:

• people → vertices,
• relationships → edges.

Now graph algorithms become available.

Representation Can Create Solutions

Sometimes no new algorithm is needed.

Changing representation makes an existing algorithm applicable.

A geographic problem becomes:

shortest path.

A scheduling problem becomes:

constraint satisfaction.

A matching problem becomes:

bipartite graph matching.

Algorithms

After representation, computational thinking asks for a procedure.

What sequence of steps transforms input into desired output?

An algorithm makes reasoning repeatable.

Automation

If a procedure is sufficiently precise, it may be automated.

This is a defining move:

from:

“I know how to solve this case”

to:

“I can specify a process that solves every case in a class.”

Automation Is Not Always the Goal

Not every problem should be automated.

Some tasks involve:

• ethical judgment,
• ambiguous goals,
• contextual interpretation.

Computational thinking can help structure them without claiming that all decisions should be delegated to machines.

Data

Before solving a problem, ask:

What data exists?

What data is missing?

What data is reliable?

Algorithms cannot repair every flaw in their inputs.

Data Representation

The same real-world fact can be represented differently.

A date might be stored as:

• text,
• integer timestamp,
• structured year-month-day tuple.

Representation affects what operations become easy.

State

Many problems become simpler when expressed as states and transitions.

Examples include:

• games,
• workflows,
• protocols,
• planning.

A state captures what matters now.

A transition captures how change can occur.

Search

Once a problem has a state space, solving it may become search.

We ask:

Which sequence of transitions leads from:

initial state

to:

goal state?

This unifies many apparently unrelated problems.

Example: Maze

A maze becomes a graph.

Intersections are nodes.

Passages are edges.

Now breadth-first search can find the shortest path in an unweighted maze.

The visual puzzle becomes a formal structure.

Recursion

Some problems contain smaller versions of themselves.

Examples:

• tree traversal,
• divide-and-conquer sorting,
• directory structures.

Recognizing recursive structure can simplify both reasoning and code.

Invariants

Computational thinking also looks for properties that remain true during a process.

An invariant helps answer:

What must never break?

Examples:

• sorted prefix remains sorted,
• account balance constraints hold,
• tree ordering remains valid.

Invariants support correctness.

Edge Cases

A computational thinker actively looks for boundaries:

• empty input,
• one element,
• maximum size,
• duplicate values,
• malformed data.

Edge cases reveal hidden assumptions.

Specification

Before implementation, define:

What should the system do?

A specification separates:

desired behavior

from:

how that behavior is achieved.

Without specification, correctness is undefined.

Testing

Testing samples behavior.

It can reveal bugs.

But finite testing cannot prove correctness for all inputs.

Computational thinking combines testing with reasoning.

Complexity Awareness

A correct algorithm may still be unusable.

So ask:

• How does runtime grow?
• How much memory is needed?
• Does the method scale?

Scale is part of the problem, not an afterthought.

Approximation

Sometimes exact solution is too expensive.

Then computational thinking asks:

What approximation is acceptable?

Can we quantify the error?

This reframes success.

Heuristics

When exact guarantees are unavailable or too costly, heuristics guide search.

A heuristic is not a proof.

But it may make a difficult problem practically manageable.

Randomness

Randomization can simplify algorithms.

Examples include:

• sampling,
• randomized search,
• randomized hashing.

Computational thinking includes probabilistic methods when deterministic certainty is unnecessary.

Parallelism

Some problems contain independent work.

Then computation can be distributed across processors.

But parallelism introduces:

• synchronization,
• communication,
• race conditions.

Splitting work creates new structure.

Distributed Thinking

A distributed system has no single global viewpoint.

Nodes may know only local information.

Reasoning must account for:

• delay,
• failure,
• disagreement.

This changes the nature of algorithms.

Human Computation

Some tasks are easier for humans than machines.

Projects can distribute work across people.

Examples include:

• labeling,
• verification,
• citizen science.

Computational thinking can organize human and machine capabilities together.

Computational Thinking in Science

A scientist may ask:

Can this phenomenon be:

• simulated,
• discretized,
• approximated,
• modeled as a network?

These are computational questions.

They influence scientific theory.

Computational Thinking in Daily Life

The same habits appear outside computing.

Planning a trip:

• constraints,
• routes,
• costs,
• priorities.

Organizing a project:

• dependencies,
• deadlines,
• resources.

Not every use requires software.

The Risk of Over-Formalization

A computational representation can make a problem look cleaner than reality.

Human situations often contain:

• ambiguous values,
• changing goals,
• unmeasured variables.

Formalization can hide what was excluded.

Optimization Changes Behavior

Once a metric becomes an objective, systems adapt around it.

Goodhart’s law warns:

When a measure becomes a target, it can stop being a good measure.

Computational thinking must include awareness of feedback.

Computational Thinking and Ethics

Encoding a decision requires choices.

For example:

What counts as:

• success,
• risk,
• fairness?

These are not always technical questions.

Formal systems inherit values from specifications.

Programming Is One Expression

Programming is a way to implement computational thinking.

But computational thinking can occur without writing code.

It begins earlier:

in representation and problem structure.

The Philosophical Lesson

Computational thinking is the art of turning complex situations into manageable formal structure.

Its core moves include:

• decomposition,
• abstraction,
• representation,
• algorithm design,
• evaluation.

Its power comes from simplification.

Its danger comes from forgetting what the simplification removed.

The Next Question

Among all these moves, abstraction and representation may be the most fundamental.

A problem can be impossible in one form and easy in another.

What makes a representation good?

What is hidden when we abstract?

That leads to:

Abstraction and Representation.