MOOSE project -- looking for a language (Francois-Rene Rideau)
Thu, 20 Oct 1994 15:45:36 GMT

          From comp.compilers

Related articles
MOOSE project -- looking for a language (1994-10-20)
| List of all articles for this month |

Newsgroups: comp.compilers
From: (Francois-Rene Rideau)
Keywords: design, question
Organization: Compilers Central
Date: Thu, 20 Oct 1994 15:45:36 GMT

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

Post a followup to this message

Return to the comp.compilers page.
Search the comp.compilers archives again.