Sunday, June 17, 2007





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.

Tuesday, June 12, 2007





It's an emulated world. Emulators I've used just within the last 12 months.

  • QEMU: Plan9, Linux
  • BeebEm: BBC Micro
  • RedSquirrel: RiscOs 3.1
  • VisualBoyAdvance: GBA
  • DeSMuMe: Nintendo DS
  • Smalltalk VM: Squeak
  • Lisp VM: Scheme
  • Dis: Inferno
  • JVM: Java
  • Microsoft CLR: .NET