One stream from Finland
Sun, 27 Apr 1997 22:53:46 +0300 (EEST)
Hello everyone on this exciting list!
We here at the Helsinki University of Technology (.hut.fi) have been
independently sketching a Scheme-based operating system to be later
implemented and further researched as some kind of a [big] student
project. I am an undergraduate CS student, fairly accustomed to
Scheme, and somewhat leading this "SchemeStation" project at this
early point (however, there are professors involved too). I'm now
posting just to tell here what we have discussed this far---to give
some ideas, if possible.
In short, we have considered a system that is based on actors
communicating only via asynchronous message passing. Actors themselves
are single-threaded units of execution having a list-based heap as
their memory. We are going to use virtual machine architecture with
some VM instruction set that is suitable as a target of compilation
for Scheme and some other (partially) functional languages such as
Haskell. Of course, we don't want to stick to any particular language
on the low level. However, we give programs executing on VM
list-structured, garbage collected heap, and this is the only memory
model that will be supported.
We have been thinking this actor paradigm because we are dreaming
about a distributed operating system where the barrier between local
and remote machines were blurred out. The actor model is very suitable
I myself see, that in any new OS it is of crucial importance to
incorporate into the deepest kernel two things: distribution and
security, both things that have been somewhat overlooked until the
current explosion of Internet. We are aiming at both of them with the
actor architecture. Whatever the LispOS will eventually look out, it
must (IMHO) address these things.
We are planning to drop out any filesystems, and have persistent
actors instead. Some people here at HUT have done much research on
shadow paged databases, functional databases, garbage collection etc.
and we could be able to deploy the results of that work.
What we hope we were able to achieve and implement in this project is
- migration of executing code between computers, transparently
from the user
- updating running programs with new code without need to restart
- security built in the lowest layers of the OS
- easily administrated user environment via Java-style downloadable
byte code, with vendor digital signatures / other certificates
to ensure trustworthiness of programs
- NO low-level (e.g. C, C++) programming!!!
I myself like Scheme very much, and become day after day more
convinced of the fact that I want a full-blown, working programming
environment where Scheme (or something like that) is what C is now.
* The blood of Christ cleanses from all sin. *