One stream from Finland

[Antti Huima]

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
to this.

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
(among others):

  - migration of executing code between computers, transparently
    from the user

  - updating running programs with new code without need to restart
    the program

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

-- 
  Antti (Antti.Huima@hut.fi)
              * The blood of Christ cleanses from all sin. *