Scheme compilers

[Kragen]

On Wed, 9 Sep 1998, James A. Crippen wrote:
> Well, I hadn't admitted it yet, but I was planning to base quite a bit of
> Schema (the OS's name, if I haven't mentioned it) off of *nix concepts
> anyway. Much of the structure would be greatly different because of the
> different language paradigm, but the abstract view would be somewhat
> familiar to a *nix hacker. 

Hmm.  What's the point, then?

Seems to me that the big benefits of a Lisp OS would be:
- unilinguality -- no need to learn a dozen languages to hack it, like
  you must with Linux.  (C, make, x86 asm, sh, SPARC asm, and probably a
  few more if you want to write software that runs on it.)  Now, I like
  languages, but it seems to me that unilinguality is potentially a big
  win for new folks -- won't take them nearly as long to get up to speed.
- stability -- it wouldn't crash or Oops unless it was running on buggy
  hardware, no matter how bad the code you linked into it.
- simplicity -- you don't need a filesystem, you don't need separate
  abstractions for threads and processes, and security can be mostly taken 
  care of by the same mechanisms you use for avoiding crashes, viz. pointer
  security.
- extensibility -- you can extend things easily, on the fly, like Linux does,
  but without so much nervousness.
- writability -- it would be a lot easier to write a kernel with garbage
  collection than doing manual mm, and things like closures are nice, too.
- unified garbage collector -- so if you implement weak pointers, both the
  disk-access stuff and user programs can share the same cache, which would
  get automatically cleared out when something important needed it.
- no artificial barriers -- you don't have to worry so much about which file
  you've got something defined in, and how to share that definition with
  this other place, and whether you should just copy it or bother to create
  a new file to hold the reused functionality, etc.  (Well, I guess this might
  resurface. I guess I'd have to implement something to find out, instead
  of just talking about it.)

It seems like you'd lose all of these, except for "writability".  Have
I misunderstood?

(Also, I think that the benefits some old LispM folks remember didn't
have so much to do with the language the OS was implemented in, but
rather the excellent development environment it was implemented in.
Some of the same benefits (debuggability, traceability, source
availability, etc.) could be implemented, at least theoretically, on an
OS written in assembly.  Thoughts?)

Kragen

-- 
<kragen@pobox.com>       Kragen Sitaker     <http://www.pobox.com/~kragen/>
I don't do .INI, .BAT, .DLL or .SYS files. I don't assign apps to files. I 
don't configure peripherals or networks before using them. I have a computer 
to do all that. I have a Macintosh, not a hobby. -- Fritz Anderson