Sunday, June 17, 2007

NAME

NOTES

The acme-sac tarballs
I've been working on producing are intended to be compact,
contain all the source,
and be runnable once it is unpacked at its destination.

The complete copy of it's own source means it can grow and adapt
to its own environment. It can also create and host the tarballs
of itself, thereby replicating and dispersing itself.

This structure makes me think of spores.
The running acme-sac instance on my laptop is creating
spores which I'm casting out from
my laptop across the internet hoping that
new copies will unpack in fertile soil and form new living
cells that themselves can grow and reproduce.

This analogy is not new. And there are books on biomimicry
for subjects other than computing.
The question I have is, if the analogy is followed further and
more explicitly what will be the results?

Or put another way, should large software systems intentionally
use biomimicry as a architectural solution?

Alan Kay has used the cell analogy explicitly when describing
object oriented programming, with its use of encapsulation
to protect the inside of the object from interference, and
message passing between objects as the means of building
functionality.

Alan Kay also drew inspiration from the way the internet was
being built, whose growth and operation also mimics biology,
where each host is a kind of cell
communicating with other hosts only through message passing.
This approach has scaled very well. Is it because it mimics nature?

Another way to look at this is that if we don't mimic nature we
are doomed to fail. Failure in the sense I mean here is that
inferno as a software species will not survive longer
than the lifetime of the author.

In my analogy of acme-sac and the cell,
the cell is not an object, or a single thread, but
a single VM with its own file tree.

So far there is no purpose assigned to any individual cell.
There is no purpose assigned to the software for the end-user.
Each cell is more of a general agent, or universal object,
that finds many local purposes, hopefully useful to
the end-user so that it survives selection pressure
and gets replicated.
The only overall purpose for the systems architecture is to survive.

The goals for the tarball are to be runnable
on many hosts. To contain source so it can adapt. Be a general
agent so it can replicate, rebuild, and host the spores to disperse
to new hosts. Maybe these goals don't even need to be stated
but are always implicit in the system.

For example, inferno-os was already distributed over the internet,
and selection pressure has already caused inferno-os to
evolve, such that acme-sac is a local variation.

And there are others, a little known race lives in Australia, I believe.

But maybe by being aware of the context it might help survival.

Selection pressure might make the code smaller, more compact.
Might bootstrap the system to higher levels of complexity.

To survive it needs host environments with disk space,
cpu and networking, and power, and a symbiotic
relationship with people.