Help for Computing System Project

[Francois-Rene Rideau]

Dear Bruno,
  you don't know me, but I know yo as the author of clisp, as a BETA
user, and as a Linux hacker.
  I mail you to ask you for some advice about an ambitious project of
mine, as I see you're an intelligent and experienced programmer.

  My project is to build some new foundings for computing, as I'm sick
of existing OS'es and computing environments. I've collected a list of
features I expect from a useful computing system, and (as importantly)
reasons why I *do* need them (i.e. they're not just useful features, but
necessary features). And after having collected them, I'm looking for
an existing language that would already provide those features, or that
could be naturally extended to provide these features easily. I wanted you
to tell me if you knew such a beast (particularly if BETA could be), and
if not, if you could help me design the specs for such a language (which
is not a work for a lonely man). I've already gathered a team of people
interested in building a new OS/computing system, but most of them are
not interested or proficient about the choice or design of a high-level
language; they prefer dealing with the low-level part of it, which
should be a distributed OS, even if first built as an emulation box on
top of POSIX/Linux.

  Here are the features I need for my HLL:
- Orthogonal Persistence (this can be added to any language with scoping
 and GC)
- "OO" programming, i.e. classes as first-class objects *and*
 parametrisable by any kind of first-class; i.e. only one big space of
 objects (even if yo call them functions, or patterns).
- existential (implicit) quantification, and to solve it and many other
 problems (but introducing new ones), allow any kind of annotation of objects
 by others (this actually is only allowing hash tables by having restrictions
 on the equality semantics, together with a simple syntax)
- allow easy language extension, both semantical (=creating new constructors,
 mapping them to implementations in some other language) and syntactical
 (creating (sub)parsers for (new) objects).
- allow embedding of other languages into the HLL, with best version among
 multiple ones (and other parallel) constructs.
- provide explicit typing and program correctness prooves in natural way
- having lazy evaluation semantics, but still provide border-effects when
 necessary.

  I thought about Scheme (Lisp), but it seems too low-level to me:
no structure declaration, everything is explicitly implemented from the
cons cell, vect and few low-level constructors; and annotations don't
enter well in the Scheme frame.
  I thought about SELF (a pure OO language, which, through the OO->
functional style morphism becomes some kind of Lisp, with identifier->value
constructor as fundamental constructor), but whereas annotations become
easy, it also seems too low-level to me (as of typing), with roughly
the same reproaches as for Lisp. As for syntactical self-extensibility,
Lisp (and SELF even more) seem poor (though far from the poorest, as for
Lisp).


  Please tell me if I'm just annoying you; I'd stop it and you wouldn't hear
about me anymore.

--    ,        	                                ,           _ v    ~  ^  --
-- Fare -- rideau@clipper.ens.fr -- Francois-Rene Rideau -- +)ang-Vu Ban --
--                                      '                   / .          --
MOOSE project member. OSL developper.                     |   |   /
Dreams about The Universal (Distributed) Database.       --- --- //
Snail mail: 6, rue Augustin Thierry 75019 PARIS FRANCE   /|\ /|\ //
Phone: 033 1 42026735                                    /|\ /|\ /