1/ Programming has a strange relationship to nature.

At the bottom, we’re stuck with hard constraints: computability, information theory, memory, latency, the speed of light, heat, hardware failure.

These are not negotiable. We discover them.

But software also lets us create new effective laws almost at will.

2/ A filesystem says these bits are a file, files have names, directories contain files, bytes persist after a process exits.

A database says a transaction is atomic—even though underneath, hundreds of fallible physical operations happen over time.

A language invents objects, types, promises, ownership.

None of these things exist in physics. We made them up.

And then something curious happens: once we make them up, we have to start discovering their consequences.

3/ Humans invented the rules of chess, but we didn’t invent the fact that some position is mate in seven.

Once the rules exist, objective facts about that world follow from them.

Software is like this everywhere.

We choose transaction semantics and discover anomalies. We invent a rendering model and discover what identity must mean inside it. We define a protocol and discover behaviors nobody explicitly designed, but which follow inevitably from its rules.

At the layer where you create an abstraction, you’re a legislator.

One layer above, you’re a physicist.

4/ This is what makes abstractions so powerful: they don’t merely save code. They refactor reality for everything above them.

Once the machinery is reliable enough, the upper layer stops seeing the mess below. It inhabits a simpler world with different apparent laws.

Venkatesh Rao’s “New Nature” is useful here: technology accumulates artificial lawfulness until it becomes part of the environment itself.

Programmers do this recursively, at tiny scales, every day.

5/ Dennett’s idea of “cranes” explains how these worlds accumulate.

Evolution doesn’t start from scratch. Once it discovers a useful mechanism, that mechanism becomes part of the platform from which further complexity can emerge.

Software abstractions do the same.

Filesystems, databases, protocols, type systems, frameworks: each packages previous discoveries into structure that future systems simply assume.

A framework isn’t merely reusable code.

It’s reusable theory—accumulated search the next program doesn’t have to repeat.

6/ So there’s a recursive process:

discovery → theory → mechanism → law → nature → new discovery

We discover something about a world. We encode the discovery into an abstraction. The abstraction becomes part of the environment. The next programmer encounters our invention as nature and starts discovering its laws in turn.

Software is, in this sense, recursive nature-making.