On fleas on fleas

Soma soma@apex.net.au
Fri, 16 Jun 2000 12:30:13 +1000

Wheels within Wheels, Fleas on the backs of Fleas On the Backs of Fleas
.... On the Backs of Dogs.

Reflection is the theme of such classics as Alice in Wonderland, The
Matrix, ExistenZ and The Thirteenth Floor. It's interesting how many
such stories are about the place recently. The whole classification of
cyberpunk is the cultural meme attached to the current cutting edge of
this area (in fiction anyway)

If I may observe, psychedelic drugs are a major influence on this scene,
because of the way they facilitate reflection through transpersonal

To go too far: Though the systems upon which human thought is built(the
body and brain), are different to a computational simulation of such,
they are identical on the level of what they do. Information is only in
the ontological structure of a phenomena, no matter where you find it,
the medium is not the message. There is no such thing as two entities
sharing without a medium of exchange, a protocol or in other words, an

And finally, nothing in this universe is different in this respect.
(yes, too far perhaps) (is this OT? Hmm..)
Though objects such as hypotheses and rocks are different only in two
respects: Rocks don't have a very big vocabulary or autonomy, and
hypotheses (and ghosts and gods) only function through their believers.

Though we can only know the world through language, can we say that this
is what the world made of? When you think about it that way, it
virtually is because we cannot see it in any other way.

How do you distinguish between simulcra and 'reality'? Is there any real
difference? If in every respect a simulation is accurate, is it not a
world in a bubble? Isn't this the point of simulation?

Therefore, AI is virtually just plain I, because we too are MADE from
something (artifice). I suppose the difference is we are made by
something which uses trial and error. However, computer science is
working on how to allow computers to do just that.

If you follow my thought process, then you must agree that at some point
any given system evolves from some beginning which is above and outside
itself reaching in and giving the system a bootstrap of some sort.

I'm not saying 'god', but to use a cybernetic metaphor, there is
probably an autonomous meta-program out there somewhere (outside of our
universe) which goes about the place planting universe seeds. In fact
it's probably self-replicating, and the whole purpose of all of it is to
make things more and more and more and more and more and more ... um...
Interesting? Complex? Diverse?

Every entity, be it tangible or intangible (temporal or spatial),
contains at its core the same seed, the same kernel, and to bring it
back right down to the basic level, it is 'on'/'yang'/+ (etc) and
'off'/'yin/- (etc.), in a constant state of flux, switching at some
phenomenal speed, really at infinite speed (and therefore you couldn't
really say it was either or, but rather that it was both.)

This is getting very Taoist isn't it?

Anyway, this takes us back to something more like the topic: In the
system I have imagined, all symbols are bound to their opposites and
their aliases(synonyms and antonyms), and really they are a single unit,
because you cannot consider a thing  without considering what the thing
is not.

When someone says 'long', this doesn't make any sense unless it means
'longer than something else which is smaller' which is a reference loop.

In my design I am using linking pairs to allow transparent dynamic
loading, as well as dependency lists to manage the mapping of data from
slow storage to memory. Each linking pair also has a small flag which
indicates the status of the link, be it online (in memory) or offline
(on disk).

The other thing I want my system to implement is orthogonal persistence.
I figured the best way to do it would be some kind of queue
server/router, and making all communication between concurrent processes
operate through it, and have it dump the data at an appropriate time
interval to disk.

What I am trying to achieve is a transparently interconnectable and
hot-pluggable communications architecture that is always (in the time
frame of the commit interval) able to be just loaded right back into
memory after a power outage or whatever, and allowing very fast reboots,
and the end of the 'save' and 'commit' commands (because it is
irrelevant to the creative process, and impedes it when users are
totally engrossed and forget about it or electrical systems fail).

At present I have only just started building it, I am writing in C, but
perhaps someone could suggest another language which will give at least
50 percent of the performance of C (at present I am short on processing
resources). C is okay, but translation from an object model into a
procedural model is tedious.

I want someone to convince me why I would want to write in some other
language. You guys (well, many of you) have played with this area, what
do you use?