Why Plain Text Is Still One of the Best Technologies We Have
Short summary
Plain text persists as one of computing's most durable technologies because its simplicity—no proprietary formats, no required applications, no dependencies—makes it readable across decades and systems. The article argues that while richer tools have their place, plain text's boring reliability and portability solve real problems that fancier solutions often create.
- Plain text works everywhere without dependencies: a text file created on Linux opens on Windows, runs in terminals, works with command-line tools, and doesn't require the original application to remain in business or supported.
- Text-based formats (source code, config files, HTML, JSON, Markdown) dominate computing infrastructure because their contents stay inspectable and debuggable without proprietary software, making troubleshooting and version control straightforward.
- Plain text resists obsolescence better than proprietary formats—old text files remain readable even if encoding needs fixes, whereas recovering data from abandoned file formats often requires emulators, conversion chains, or lost software.
- Ownership and control stay with the user: text files can live in any directory, sync however you want, go under version control, or move to different machines without vendor lock-in or subscription dependencies.
Full summary
Plain text endures because it's simple and universal. A text file created on Linux works on Windows, can be searched with command-line tools, and will likely remain readable decades from now. Unlike proprietary formats tied to specific applications, plain text stores just characters without formatting baggage. That simplicity means almost nothing can go wrong—you don't need the original software to read it, and you can inspect, copy, and troubleshoot it directly. The format shows up everywhere in computing: source code, configuration files, log files, HTML, JSON, shell scripts. Even when these are structured formats rather than plain prose, their contents stay visible and intelligible to humans and tools alike.
The real power emerges when you combine plain text with the vast ecosystem of tools that already work with it. Unix utilities like grep, sed, and awk have handled text for decades and can process thousands of files without clicking through menus. Modern applications often lock data into their own systems—controlling where it lives, how it syncs, how you search it. Plain text inverts that relationship, leaving choices with the user. Markdown found a useful middle ground by adding formatting conventions (headings, lists, links) while keeping the source readable as plain text. If the Markdown processor disappears, a heading still looks like a heading. The rendered output is convenient, but the source file remains ordinary text.
Where plain text struggles is obvious: you can't embed spreadsheets, photographs, or complex layouts. Rich documents exist because presentation and structure genuinely matter sometimes. Databases enforce relationships that text files can't, and specialized software handles tasks text makes tedious. The real issue isn't using richer tools—it's assuming they're automatically better even when plain text solves the problem. A text file sitting in a directory on your computer requires no company to stay in business, no subscription to keep working, no cloud service to sync. You back it up however you want, put it under version control, move it freely. When plain text is sufficient, it removes a surprising number of dependencies that later get in the way.