MOOSE blurb in comp.compilers

[Francois-Rene Rideau]

  As I'm sick of computing systems I know, and saw no end to them, I've
decided to write my own, on my 386 PC to begin with, but in a portable way
(have an implementation over *yuck* POSIX ?).

  I'm still looking for the High-level language to use, which must be able to
integrate all the features described below. Can somebody help me ?
  I'm considering BETA, SELF, Icon, or something like that. Else I'll have to
design my own (as a self-extended typechecking FORTH-like thing ?) :( :(; but
as our moderator say, the world is not ready for yet another language, so if
I can skip the language design phase, I'd be very happy.


  The project is called MOOSE, and I'm writing it alone. It means
Multi-* Object-oriented Operating System and Environment. *I* didn't choose
the name as I wasn't alone at that time.

  It's a project for an OS that will change you from Un*x and
sub-clones like MS-DOG:
- of course multi* (tasking/threading/user)
 This implies a language not centered toward global variables (no "C"), with
 an ability to understand concurrency (with current-continuations ?).

- persistence, thus garbage collection, security, type-checking
 (thus again no "C") that means no *need* of file system (but still support
  them to communicate with other OSes. 
 That also means *need* for a language that supports secure type-checking and
 orthogonal persistence.

- machine-independent low-level (stack-based/FORTH-like ?) language for
 portable binaries, with common interpreter or compiler back-end.
  This implies nothing for the HLL.

- partial lazy evaluation and optimization for ideal dynamic performance
 This implies a HLL with lazy evaluation semantics.

- no-kernel (not even micro- or nano-) architecture. Everything is
 decentralized in modules (even the module loaders). The only thing needed
 is a boot module. Modules communicate through conventional protocols (which
 may change by replacing all concerned modules).
 This implies the existence of a good module system for the HLL (unlike
 the C header file bullsh*t).

- system specifications open for a distributed version where objects migrate
 or are copied on the fly from host to host to achieve best performance
 (but security required more than ever).
 If the language is truely high-level, this shouldn't affect it.

- Author authentification to retribute authors, or give them (dis)credit.
 It would be *very* useful if the language allowed arbitrary annotation of
 objects, which may mean things about object equality semantics (if
 association tables are to be built).

- dynamic typing high-level (some may say "object-oriented") language as
 a standard interactive development tool -- no *need* for a shell and a
 bunch of stubborn languages that cope with each other's flaws. All systems
 specification are done in such a language. The language should have natural
 extensions that allow program specification and proof, and do secure
 type-checking.
  That's the language I'm looking for.

  I'm also considering joining Mike Prince's PIOS project, or the FIRE project.
If there's another project (personal/university/commercial) that includes all
(or a big part) of those features, please tell me. If you see any reason why
it shouldn't be possible or wishable, or that it does not go for enough, or
that it goes in the wrong direction, please tell me too. I *think* I am
open-minded enough to hear it.


  Any help, comment or feedback appreciated.
  Please reply by mail (but you may post your reply *too*), as I may not be
reading your group. Sorry for the noise if you think it doesn't fit the group.
  Thanks.