“The larger the system, the more valuable its plain-text foundation becomes.”

There is a persistent myth in computing that plain text is only suitable for small things.

People imagine plain text as something for shopping lists, programming notes, configuration files, or the occasional README. Surely, once documents become large, projects become complex, or organizations become serious, we need “real” file formats with sophisticated software to manage them.

The truth is almost the opposite.

As information grows in size and complexity, plain text becomes more valuable, not less.

The Invisible Foundation

Take a moment to think about everything you interact with on a computer.

Books. Websites. Scientific papers. Presentations. Financial reports. Programming languages. Configuration files. Spreadsheets. Databases.

These appear completely different on the screen.

Yet, remarkably, almost all of them begin life as text.

A website is HTML.

A LaTeX paper is text.

A Quarto project is text.

A Typst document is text.

A JSON API is text.

A CSV dataset is text.

A shell script is text.

Even this article started as a plain text file before becoming a beautifully formatted web page.

The finished product may be colourful, interactive, and professionally typeset—but somewhere behind it is an editable text source.

Printing Is the Final Stage

One lesson I have learned over the years is this:

Anything that can be printed usually has a textual description somewhere.

A PDF is not normally edited directly.

Neither is a printed book.

Neither is a printed invoice.

Instead, there exists a source document from which those final versions are produced.

Authors edit manuscripts.

Programmers edit source code.

Publishers edit markup.

Designers edit project files.

The printable document is often only the final rendering.

That is why professional publishing has long preferred source-first workflows.

Edit the source.

Generate the output.

Repeat.

This idea existed decades before Markdown became fashionable.

Proprietary Formats Come and Go

Software companies naturally promote their own document formats.

Word processors have proprietary files.

Graphic design programs have proprietary projects.

Presentation software has proprietary slides.

These formats are often excellent while the software is actively maintained.

But software changes.

Companies disappear.

File formats evolve.

Licensing changes.

One day, you may discover that an old document no longer opens correctly.

This is where plain text quietly demonstrates its greatest strength.

Even if your favourite application disappears tomorrow, a text file created thirty years ago is still just text.

It may require interpretation.

It may require conversion.

But it remains readable.

That is an extraordinary promise.

Preservation Begins With Source

If a document matters, preserve its source.

Not merely the exported PDF.

Not only the printed copy.

Preserve the editable source.

This principle applies everywhere.

A book should keep its manuscript.

A website should keep its Markdown.

A thesis should keep its LaTeX or Typst sources.

A presentation should keep its Quarto project.

A finance report should keep its ledger files.

When the source survives, new outputs can always be generated.

Lose the source, and you are often forced to rebuild everything from scratch.

Version control systems such as Git reinforce this philosophy beautifully.

Rather than archiving hundreds of slightly different Word documents—

report-final.docx

report-final-revised.docx

report-final-final.docx

—you preserve a single evolving source along with its entire history.

Even Rich Documents Reduce to Text

“But Word documents aren’t text.”

Technically, they contain far more than plain text.

Yet if disaster strikes, what do we try to recover?

The words.

Not the margins.

Not the animations.

Not the exact font.

The content.

When migrating between applications, what survives best?

The text.

Formatting can usually be recreated.

The ideas cannot.

In the end, information matters more than presentation.

Plain text separates the two.

The Data World Already Knows This

Data analysts have quietly embraced this lesson for decades.

Consider a typical data science project.

The datasets are often CSV.

The metadata is YAML.

The configuration is JSON or TOML.

The analysis scripts are Python or R.

The documentation is Markdown.

The notebooks are text-based.

The version control history is text.

Even when enormous databases are involved, importing and exporting plain text formats remains routine.

Text has become the universal language through which systems exchange information.

The prettier interfaces are often just convenient windows onto that foundation.

Plain Text Grows With You

One of the surprises awaiting new textsmiths is that the same skills continue to work as projects become larger.

Searching becomes faster with tools like grep and ripgrep.

Transformation scales with sed.

Analysis scales with awk.

Composition scales with pipes.

Automation scales with shell scripts.

Version control scales with Git.

Documentation scales with Markdown and Quarto.

Publishing scales to websites, books, PDFs, and presentations.

The tools change very little.

The size of the project changes dramatically.

That is rare in computing.

Looking Ahead

Over the coming weeks, this blog will begin exploring another world built almost entirely on plain text: data analysis.

Spreadsheets certainly have their place, and they remain excellent tools for many kinds of work.

But behind modern data science lies a surprisingly familiar landscape filled with CSV files, SQL queries, JSON documents, scripts, notebooks, and command-line tools.

In other words, more text.

The larger the data becomes, the more important reproducibility becomes.

The more important reproducibility becomes, the more valuable plain text becomes.

That is no coincidence.

Final Thoughts

Plain text does not compete with polished documents.

It enables them.

It is the manuscript behind the novel.

The markup behind the website.

The ledger behind the financial report.

The script behind the graph.

The source behind the PDF.

Software brands will continue to rise and fall.

File formats will evolve.

New applications will replace old ones.

But plain text remains the common language beneath them all.

That is why it has survived for more than half a century.

And that is why it scales far better than most people imagine.