On fleas on fleas

Soma soma@apex.net.au
Fri, 16 Jun 2000 18:29:53 +1000

Youlian Troyanov wrote:

> Sounds cool. But it's still unclear (at least to me) what your code will
> do. Could you elaborate ?
> Thanx,
> Youlian

I'm not sure where to start...

I'll start by spouting a bunch of buzzwords:

I'm calling it Simulcra (for some reason I feel it wants a 'The' in front
of it). It will be a system similar in intention to the system described in
'The Arrow Philosophy' (I reccommend reading it... Haven't finished reading
it yet, but it's really good)

Using a tree-graph type linking to join symbols with their contexts (In
truth every idea exists inside the context of another idea, except for the
idea of the idea, which is self-referential( reflective)). This data
structure can contain or reference every type of data the system can use,
it doubles as a state machine (grammar recognition), it stores user files,
it will store the system itself, and it will store language modules,
allowing translations between languages (both human and computer - and
whatever else people think of). It is not intended to be AI, but rather a
cybernetic assistant, who understands your idiosyncrasies because it adds
your set of aliases for things to its lexicon, and theoretically could
enable anyone to program.

The other thing the system will do is orthogonal persistence. This will be
made possible through a communication system which will use some kind of
tag structure (perhaps addresses to symbols referenced), and it can
transparently add other (I will call them pipes to confuse everyone) pipes
that may be operating over ethernet or whatever you want, transparently to
the programs.

Persistence will be provided by a central exchange system (we will call it
a switch) which performs two functions: One is to regularly write its
buffer to disk in the event of system failure. The other function of the
switch is to finally send the data to its desired storage location (file)
Actually it does these things at the same time.

Apple's iBook has a function where it dumps memory to disk and then upon
power up it dumps the data back into memory and it starts up almost

I wish to provide such a facility transparently to the user. To enable
this, first all temporary data is periodically committed to disk, and
likewise the process list of the executive will also be dumped periodically

To allow the storage of temporary data, all running processes variable and
memory manipulations are tied together by the previously mentioned linked
web type structure associated with each process, where each module modified
sends a message to the switch notifying it of the changes, and at the
interval the switch commits data, it will add to its list the changes in
the data.
When a process changes one piece of data a number of times,  during the
interval, it doesn't matter how many times, it only dumps the state as it
stands on the commit interval.

Anyway, that's what I'm thinking at the moment. There's an interesting OS
project that is working on making persistence as efficent as possible, but
I am not too concerned about this. I will probably include profiling in the
system too (I am quite obsessed with efficency of code actually). The way I
will do this is by using a incremental optimisation function which passes
over each piece of executed machine code, looking for redundancies and
waste and though it might start out inefficient, the more code runs the
more efficent the system will make it. (I got that idea from the crusoe
processor) It would be set to do it every ten or twenty executions or
something like that.

The other thing about this OS is that it will be modular right down to the
level of individual functions, where only one name is associated with one
process, though the process may call on others and thereby abstract them
into itself. The purpose of this is to eliminate all redundant code.

I am presently CVSing ExoPC, and the idea of dumping the layering of an OS
appeals to me, as though I haven't witnessed it or looked at much in the
way of benchmarks, it makes sense to me. Administration of data is the most
wasteful activity that a system does - I will try to make all such parts of
my system as svelte as possible.

One of the desired goals of my system is to dump every other system of
database storage and manipulation in favour of a single set of functions
with a more broad application: hence every resource the computer can access
is tied together by the same system of DBM, so that I only have one code
set to optimise, rather than ten or twenty. (Explain you say:-) Well, the
average OS has a mechanism for storing its executive process information,
and a separate DBMS for the filesystem, and yet another one for the dynamic
loader, and yet another one for compiler state machines, and yet another
one for ... um. You get the picture anyway. I am not saying I can do it any
faster than anyone else determined to do it fast, rather that I will make
it as simple and broadly applicable as possible so as to reduce the
complexity and size of the system. Simplicity also pays off in maintenance
costs: it means there is much less you need to maintain.

Simplicity and elegance are the primary goals of this system.

Anyway, that takes me back to an unanswered question

To quote myself:

> 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?

Um, I can't remember what it was about, but Pliant looked interesting.

The other thing is that I may soon be able to burn processing time (When I
get a job finally, and a decent computer), and then I may not care.

This is just about the definitive description at the moment... I really
should write a paper on it or something.