My description of paradise at the end there sounds like a software
spec, and I think that's right.

Project our interactions with computers onto a 2/.5  dimensional
space, in which programs are space-filling and non-dense, a sort
of consensual illusion to understand our surroundings and events
streaming by.

I argue that programs as consensually non-dense space filling
objects is a cultural interpretation of what a running program is
and not an unnecessary performance constraint.

Consider old computer challenge. Many, like me, have had the
revelation that all of the gigabytes of memory and extra processor
cores do a mixture of nothing, and failingly supporting their own
weight. The hassle is when classical software or hardware that
worked is gone, replaced by an out of control yak. Such as my
audio woes (presumably) when my cassette tape deck was basically
fine- except it would need an obscure set of connectors to get to
universal serial bus latest, now.

Does placing foreground running programs spatially limit them? No.
Those extra processors were basically idling, even though you
could be hyperspatially stacking more processes than you can count
on your fingers. Instead, we often physically space out computers.

The router is here, the modem is there- when those are near enough
indistinguishable from softwares. The computer with the graphics
acceleration is over there, since it's noisy.

I guess we come to agree that the universe is basically a lispm
with programs strewn about its foreground that can be spatially
navigated to and between.

Just like the abstraction in the 70s-80s, networks can be seen
as connected ether paths (okay, at the time they were very
physical too) where two paths touch at gateways, and these
paths and gateways form the traversable streets of the matrix.

The abstraction at the time (in Moon's AI memo) was that each
server was operating in its own separated off virtual ether,
gatewayed just to the main street. This metaphor is literal in
all sorts of ways and intuition-building.

In the ether model, you could also see what was passing by past
the window of your own virtual ether, when you weren't personally
using the ether street.

Admittedly, a lispm can in general offer several different
chaosnet services, whereas my argument was that each program
would sit in a spatially laid out matrix. Though since a given
server's services are probably related, whole servers can be
considered as programs.

I think we can agree that programs/servers/nets are already
spatially organised, and the only next step is to share a
cultural illusion of describing and discussing this with others.

Aside: Harnessing old computers, a single server won't be all
singing and all dancing anyway.


Nowwww we get to my big ask. In my earlier phost, I describe
fighting bland, homogeneous, pro-data-scraping-business style
by personally maintaining extremely local, tightly integrated,
local purpose forks of other code, rather than pulling in that
code as an "external" entity, and taking responsibility for
downstreaming updates that make sense to you.

(Upstreaming is extremely costly: This is what foils the data
merchants trying to scrape you as well).

So instead of having single-use factory garbage shipped in
for every separate purpose, each of us basically fill a
spatially local and absolutely contextual niche, and we
don't try and hyperspatially stand on top of each other,
because that's a bad abstraction and not what we do anyway.


This could probably go for a revision but welcome to the matrix.