I spent the afternoon writing a tiny HTTP server,
that can route requests from multiple domain names pointed at it.

It is just 25 lines of code,
and maybe another 50 in reusable functions.

It has good code readability,
but not because I took extra time to clean it, which I did.

But because it is a program,
that just does one thing well.

This is often quoted,
as the UNIX way.

It is a strange thing to talk about,
and a strange revelation.

But large programs simply cannot be readable,
unless they are built out of multiple small commands.

Writing tiny commands,
to operate a larger system.

It not just for operating system,
but the way to do large programs right.

As a bonus,
a person is then able to log into a large program...

And manipulate it,
inside out.

This allows for new types of tests,
and viewing the program from a new perspective.

Which allows for inviting multiple programmers,
to work on the program command at a time, inside out.

I suppose the data storage,
must always be tables that can be joined on some common field, like userid.

But if it is an unusual program,
then the commands should operate on a tree of locations.

Not exactly a tree of folders,
but just a tree of infinitely nestable locations.

I think all concerns such as code quality, or portability,
or readability, even technology is secondary...

To being able to replace the program,
inside out, one command at a time.

All of these patterns are with us,
they are databases, file systems, commands.

They are here, not because,
that is how data and operating systems need.

But because THAT is how programs that last,
are written.