I've Been Programming Long Enough to Watch Old Ideas Become Cool Again

One of the advantages of being around computers for a long time is that eventually you get to watch the industry invent things you've already seen.

This is extremely entertaining.

The new thing arrives with a modern name. There is a website. There is usually a gradient. Somebody announces that software development has fundamentally changed.

You look at it and think, Isn't this basically the thing we had fifteen years ago?

No.

Absolutely not.

This one uses YAML.

Completely different.

Old Ideas Rarely Die Properly

Unix is particularly good at refusing to stay dead.

Small programs. Text streams. Pipes. Files. Processes that do one thing reasonably well.

These ideas have been declared primitive many times. The future was supposed to be enormous integrated environments, then services, then microservices, then serverless, then platforms, then increasingly elaborate orchestration systems designed to coordinate the enormous number of tiny things we created after deciding enormous things were bad.

Meanwhile:

cat file | grep thing

Still there.

Still working.

Nobody has managed to raise venture capital to disrupt it.

Text Keeps Winning

This one fascinates me.

Every few years somebody attempts to rescue us from plain text. We will have rich structured formats. We will have databases for everything. We will have visual configuration. We will have magical interfaces.

Then twenty years later there is somebody using Git to version a directory full of text files.

Why?

Because text is almost offensively durable.

You can inspect it, diff it, search it, pipe it, email it, recover it, generate it, and open it on a machine built by somebody you've never met.

Plain text is not exciting.

Plain text has simply survived everyone who tried to replace it.

The Command Line Keeps Surviving Too

Graphical interfaces are obviously better for enormous categories of work. I would not like to edit photographs using awk.

But for many technical tasks, the terminal possesses an annoying property: it composes.

You take one tool, then another, then another, and suddenly you've created a workflow nobody explicitly designed.

Modern software keeps rediscovering this under different names: automation, pipelines, composability, agents, tool use.

The terminology changes. The underlying pleasure remains.

Take small capabilities and connect them.

Unix people have been smirking about this for decades.

Old Does Not Mean Correct

There is a danger here. Old programmers occasionally become historical reenactors.

Everything was better in 1994. Software was small. Men were men. Computers made reassuring beige noises.

This is nonsense.

A vast amount of old software was terrible. Old tools had limitations we have happily forgotten. Modern systems can do astonishing things.

The interesting part is not that old ideas were always better. It is that certain ideas keep returning because they correspond to something fundamental: simplicity, composability, inspectability, local control, text, small interfaces.

These things repeatedly become unfashionable.

Then software grows complicated enough that somebody rediscovers them.

A new generation announces the discovery.

And somewhere an old Unix programmer smiles faintly and goes back to whatever he was doing.