Beginners often see a text file as something to be edited. However, as we see in this issue’s Dispatch on pandoc, a textsmith sees it as something that can be transformed.

That difference changes everything.

The World as Text

Suppose you have a thousand files that contain:

Old Company Ltd.

which now needs to become

New Company Ltd.

Many people imagine opening each document one by one.

A textsmith immediately asks a different question:

“How do I transform this stream of text?”

The files themselves become almost secondary. What matters is the transformation.

This mindset is at the heart of the Unix philosophy.

Editing Is Just One Transformation

Search-and-replace is perhaps the simplest example of a transformation.

sed 's/error/warning/g'

This command is not really about editing.

It says:

Whenever you encounter this pattern, replace it with another.

Notice how there is no mention of windows, cursors, selections, or even files.

It simply describes a rule.

That rule can be applied to one line…

…a hundred files…

…or an endless stream flowing through a pipe.

The transformation remains exactly the same.

Streams Rather Than Documents

Traditional office software encourages us to think in terms of documents.

The terminal encourages us to think in terms of streams.

Imagine data flowing through a pipeline:

input
   │
   ▼
search
   │
   ▼
replace
   │
   ▼
sort
   │
   ▼
filter
   │
   ▼
output

Each stage changes the data slightly before handing it to the next tool.

Instead of editing a document, you are refining a stream.

This is why pipelines feel so natural to experienced shell users.

Every command performs one transformation before passing the result onward.

Small Rules Become Powerful

One search-and-replace rule may seem almost trivial.

s/cat/dog/g

But transformations compose.

You can replace text…

…then remove blank lines…

…then sort the results…

…then eliminate duplicates…

…then extract only one field…

None of the individual commands is particularly impressive.

Together they solve surprisingly complex problems.

Programming itself often works this way.

Large programs are usually nothing more than many small transformations composed together.

Thinking in Patterns

Textsmiths gradually stop looking at individual words.

Instead they begin seeing patterns.

For example, rather than searching for

January
February
March

they may recognize that these are all months.

Instead of replacing a single telephone number, they identify the pattern that defines all telephone numbers.

Instead of matching one filename, they describe an entire family of filenames.

Regular expressions make this way of thinking possible.

The goal is no longer to edit this piece of text.

The goal is to describe the structure of many pieces of text.

That is a profound shift.

Beyond Text

Interestingly, this way of thinking spreads into other areas.

Configuration files become transformations of system behaviour.

CSV files become transformations of data.

Markdown becomes a transformation into HTML or PDF.

Typst transforms markup into beautifully typeset pages.

A compiler transforms source code into machine instructions.

Git records transformations over time.

Even version control is ultimately a history of changes.

The computer spends much of its life transforming one representation into another.

Why the Terminal Feels So Natural

People sometimes wonder why experienced Unix users seem so comfortable in the terminal.

Part of the answer is that the shell is built around transformations.

One command produces output.

Another command consumes it.

Every tool expects text.

Every tool changes text.

The shell does not ask you to think about applications.

It asks you to think about processes.

Once that mental model clicks, many previously difficult tasks suddenly become straightforward.

Learning to See Differently

Search-and-replace is often introduced as a convenience feature.

To a textsmith, it is much more than that.

It is an introduction to transformational thinking.

Instead of asking,

“How do I edit this?”

you begin asking,

“What rule describes the change I want?”

That question scales.

It works for one line.

It works for one file.

It works for an entire directory tree.

It works for data arriving over a network.

It even works for programming.

Learning commands is useful.

Learning transformations is transformative.

The command you type today may be forgotten tomorrow.

The habit of seeing information as something that can be described, transformed, and recomposed will stay with you for the rest of your career.

That, perhaps more than any individual tool, is what it means to think like a textsmith.