Garden: The Future is Content-Addressed

OSI was formalized in 1984.
Also in 1984:
"End-to-End Arguments in System Design."
(Saltzer, J.H., Reed, D.P., and Clark, D.D.)

The principle, called the end-to-end argument, suggests that functions placed at low levels of a system may be redundant or of little value when compared with the cost of providing them at that low level. Examples discussed in the paper include bit error recovery, security using encryption, duplicate message suppression, recovery from system crashes, and delivery acknowledgement. Low level mechanisms to support these functions are justified only as performance enhancements.

In other words:
When layers begin to introduce coordination overhead,
they reduce signal fidelity.

When OSI Got It Wrong 🌱

The Open Systems Interconnection (OSI) model was published in 1984.

The OSI model had three architects.

Charles Bachman. Honeywell. New Jersey.
He drew the seven layers.

Hubert Zimmermann. INRIA. Paris.
He formalized them.

An international standards committee. ISO. Geneva.
They approved them.

The assumption:
Meaning and routing are separate problems.
Payload flows through the wire, doesn't matter what's in it.
Meaning gets pushed to the edge.

Meanwhile, three thousand miles west.
MIT. Cambridge, Massachusetts.
Saltzer, Reed, and Clark.
Same year.

They argued:
Putting functions into layers accumulates distortion.
Layers don't have the full picture.
The full picture lives at the endpoints.

In practice today's internet is built on 4 layers.
Link. This is where the physics happen.
Internet. This is where the routing happens.
Transport. This is where the journey happens.
Application. This is where today's magic happens.

Let's go on a journey in this codebase.
You're now a packet.
Traveling with our layers.
(These rascals.)

When You Enter the Wire

Before this moment, everything was open.
Some things seemed possible.
Others seemed more unlikely.
(Like changing the world.)

Then you entered the wire.
And your mission became clear.
You need to reach your destination.
Deliver the payload.
(Whatever the cost.)

You're now a stream of raw bits
that entered a physical wire.
You need to reach your destination.

When You Jump Nodes

You arrive at your first stop.
You know where you need to go.
(And this is not it.)

You ask around if someone knows where your destination is.
Nobody can help.
They just redirect.

"Ask the next node."
They keep saying.

So you do.
You re-enter the wire.
And jump to the next node.

This one also doesn't know the way.
But they know someone who might know.

So you go there.
You need to reach your destination.

When Layers.. Disagree 🌱

Eventually you get.. stuck.

Reality changed around You.
A network table update.
Nobody told you.
(Nobody could.)

TCP, to reduce uncertainty,
lets only a few packets pass at any given time.

TCP is protecting the network.
RTT climbed: Congestion window reduced.
Doing their best with incomplete information.

Application meanwhile is waiting.
Timeout crosses.
So they retry.
(Impatiently.)

Now there are two of You.
Same payload.
Same degraded path.
Neither knows about the other.

Eventually TCP lets you pass.
(It took forever.)

You arrive at your destination.
They welcome you.
They smile.

Then they say:

Thank you. You are no longer needed.
Someone else arrived here first.

..

Every layer's metrics are green.
Every layer made the right local call.

Application: recovered from timeout.
Transport: Protected the network.
Internet: Updated the optimal route.

The system is polite.
The system is correct.
The system doesn't care.
And nobody will tell you.
(Not even the logs.)

This is not a bug.
This is a category error.

Each layer optimized for its own invariants.
No layer had visibility into the others.
Each assumed coherence was someone else's responsibility.

Seven layers in OSI.
Rationalized to four layers in practice.
(Good effort. Hard problem.)

The question isn't:
"Who failed?"

Failure is inevitable.
Murphy's law.

Yet invisible failure is dangerous.
It's owned by no one.
And paid for by the commons.
(Privatized profits, externalized costs.)

..

Let's ask the real question:
"How can we do better?"

When Alignment Happens 🌱

I(X; Z) ≤ I(X; Y)

Shannon, 1948.

In any chain X → Y → Z.
Information can only be lost.
Or preserved.
Never gained.

The implication is clear:
Reduce the number of layers in transmission.

Ideal: Direct communication
between source and destination.

Reed and I are exploring an alternative.
Content addressed distribution.

Each node becomes an Actor with a shasum -a512 address.
Each route becomes a sequence of typed transformations
between content-addressed Actors.
(Fully local by default.)

Messages between Actors become signed git patches.
And whether any given actor is local or remote becomes irrelevant.

We're calling it "garden". (More in Sunday's Members essay.)
Built in Conversation. A typed tree-native language, already compiling.
Where full observability is part of the runtime.
And where systems can observe their own state.
In realtime.

Cheers
Alex 🌈