The Power of Plain Text

Looking Under the Hood

After nearly 30 years as a software consultant across dozens of industries, I've noticed a recurring conversation. Someone in my life - a friend, family member, client in a non-technical role - expresses frustration with their technology. They describe a problem they're trying to solve and ask what app I use for that purpose.

In these moments, I find myself hesitating. The truth is, what I actually use often isn't what they're expecting to hear. Instead of pointing them to a polished SAAS product with a monthly subscription, my real answer would be "a collection of plain text files in a git repository" or "a simple script I wrote that does exactly what I need and nothing more." But I know this answer isn't helpful to them, so I recommend something more accessible, but less ideal instead.

This divide shows up everywhere once you start looking for it. I've watched non-technical clients struggle to recover work from proprietary file formats after software updates, while my plain text notes from a decade ago open instantly on any device. I've seen teams spend hours debugging configuration issues that stemmed from hidden formatting in files. These aren't isolated incidents - they're symptoms of a deeper pattern about transparency versus convenience, about seeing versus assuming.

Text vs. Binary: The Hidden Divide That Shapes Your Digital Experience

Every file on your computer falls into one of two categories, though most people never think about this distinction. The difference isn't academic - it fundamentally changes your relationship with your own data.

Text files contain exactly what you see when you open them, in any of thousands of apps - letters, numbers, symbols. They're like a notebook page where what's written is precisely what's there. There's no hidden layer, no secret information, no special decoder ring needed.

Binary files need specialized software to interpret them. The actual content isn't directly readable by humans. When you open a binary file in a text editor, you see gibberish - not because the information isn't there, but because it's stored in a format that prioritizes machines over human readability.

This distinction affects nearly everything you do digitally:

• Text files: Notepad documents, markdown files, CSV data, HTML pages, configuration files, most code

• Binary files: Word documents, Excel spreadsheets, Photoshop files, compiled applications, database files, PDFs

PDF files are particularly interesting because they exist in a strange middle ground. They're marketed as a universal interchange format that anyone can open, but try editing one or extracting data from it without Adobe's tools, and you quickly run into their binary nature. Nearly everyone has experienced the frustration of receiving a PDF form they need to fill out, only to discover they can't actually edit it without specialized software.

The fascinating part isn't the technical distinction but what it reveals about different approaches to technology and information.

The UNIX Philosophy: Old Ideas That Keep Working

This text file thing isn't some new tech trend - it comes from a computing approach that's been around since the late 60s from the UNIX operating system while flashier alternatives have come and gone.

The UNIX philosophy boils down to:

1. Make tools that do one job really well

2. Design things to work together

3. Use text as the common language

It's like choosing between a kitchen with specialized tools versus one all-in-one multi-tasking gadget that promises everything but delivers mediocrity. The specialized approach wins in the long run.

Text works as the connecting tissue because any program can read and write it without special translation. No proprietary formats, no compatibility layers, no "this version doesn't support that version" problems.

I and so many other developers keep coming back to this approach because it consistently outperforms more complex alternatives. There's something worth noticing when a pattern keeps working for decades while supposedly "advanced" approaches fall apart. (It also turns out to continue to work in the world of AI, FYI)

Why This Matters Even If You Don't Write Code

So what if you never touch a command line or write a script? The plain text approach still affects your day-to-day tech experience:

What You See Is Actually What You Get

Text files hide nothing. No surprise formatting, no hidden metadata, no proprietary bits lurking behind the scenes. You see exactly what's there.

This changes your relationship with your own information. When a text file acts weird, you can see the problem and fix it directly. With binary formats, you're stuck guessing what might be wrong based on symptoms rather than causes.

This hits hardest when things go sideways. I've watched colleagues waste entire afternoons fighting with Word formatting while muttering increasingly creative curses. The same content in plain text would have shown the exact problem in seconds.

True Ownership Outlasts Software

Text files can be read on any device, with any operating system, using any text editor. A text file you create today will still be readable decades from now, even as software and hardware evolve.

This longevity isn't theoretical. I can still open text files I created as a teenager, while documents from specialized software from the same era are now inaccessible. The pattern is clear: the more specialized the format, the shorter its practical lifespan.

This isn't just about nostalgia. It's about maintaining access to your own intellectual output over time. When you store important information in proprietary formats, you're effectively betting on the continued existence and backward compatibility of specific software.

Freedom Through Interoperability

Text files are the universal donors of the digital world. They can be easily imported into different applications, processed by various tools, and transferred between systems without compatibility issues.

This interoperability gives you freedom to choose the best tools for each task rather than being locked into a single ecosystem. You can start a project in one application and continue it in another without losing data or functionality.

I've found this especially valuable as my needs change over time. Text-based notes I took years ago can be instantly incorporated into new systems as better tools emerge. The same isn't true for information locked in proprietary formats.

The Complexity Trade-Off: When Binary Makes Sense

Despite these advantages, binary formats exist for good reasons. They excel at:

• Storing non-textual data like images, audio, and video

• Preserving complex formatting in documents and presentations

• Enabling interactive features in applications and games

• Optimizing performance for specialized tasks and calculations

• Protecting proprietary algorithms and intellectual property

The key is understanding the trade-offs. Binary formats offer convenience, rich features, and optimized performance at the cost of transparency, longevity, and interoperability. Text formats prioritize simplicity, accessibility, and control over specialized functionality.

What fascinates me is how often we default to complexity without considering whether simplicity would serve better. I've watched organizations build elaborate systems to manage information that could be more effectively handled in simple text files. The pattern repeats: we gravitate toward complexity even when simplicity would better serve our goals.

This Stuff Actually Matters For Control

Once you get this text/binary distinction, your relationship with tech shifts. You start asking better questions:

• Where should I store stuff I might need years from now?

• How do I keep control of my own information?

• Which tools actually let me fix things when they break?

• When is a slick interface worth the tradeoff in control?

• Where am I getting locked into someone else's ecosystem?

These aren't abstract questions - they affect whether you own your digital life or just rent access to it. The technical details might seem boring, but they determine whether you're the driver or just a passenger. Are you willing to learn a few less flashy tools to keep control, or would you rather trade that control for convenience?

Why Developers Choose Text Files

Developers' preference for text isn't just philosophical—it's intensely practical. Text files enable:

• Version control that tracks changes with precision

• Collaboration where multiple people can work meaningfully on the same files

• Automation through scripts and command-line tools

• System transparency that makes troubleshooting straightforward

What's particularly interesting is how these same benefits apply beyond software development. I've found that managing my own writing, research, and project documentation in text formats gives me many of the same advantages that developers rely on.

The Pattern Behind the Pattern

The preference for plain text reveals a deeper truth about technology: sometimes the simplest solutions are the most powerful and enduring. In a world where digital tools and formats multiply endlessly, text files remain a constant—accessible, reliable, and transparent.

This doesn't mean converting everything to plain text. It means developing awareness of different approaches and their implications for your digital autonomy. It means recognizing when simplicity serves better than complexity, when transparency matters more than convenience.

What I've found most valuable isn't abandoning modern tools but developing the judgment to know when plain text serves better than proprietary formats. This isn't about technological purity—it's about making intentional choices based on what matters most for each use case.

This pattern—of seemingly simple technology proving more durable and valuable than complex alternatives—shows up repeatedly across domains. Understanding it has changed how I approach not just file formats, but digital tools and systems of all kinds.

Plain Text Coming Full Circle

It's fascinating to see how this text-based approach is starting to come full circle. Tools like Obsidian bring many of these text-file advantages to non-developers in a way that feels approachable rather than intimidating.

Obsidian is essentially a fancy viewer for plain text files written in Markdown. It stores everything in "plaintext Markdown files containing only the text you enter," which means your notes aren't locked into their system. If Obsidian disappeared tomorrow, all your notes would still be perfectly readable in any text editor.

What makes tools like this interesting is how they combine the best of both worlds - the visual accessibility of modern apps with the enduring foundation of plain text files. This approach makes your notes "future-proof" and compatible with other software solutions rather than trapped in proprietary formats that only work with specific programs.

I've watched friends who previously rolled their eyes at my text file evangelism suddenly get excited about these same principles once they experienced them through a tool designed for non-technical users. The underlying value proposition is identical - ownership, portability, longevity - but the presentation makes all the difference.

These tools show a promising middle path: interfaces that feel modern and accessible built on foundations that respect user autonomy and data longevity. As one review put it, they "keep my data secure and under my control, and allow me to decide which features I need and which I don't."