release 0.0.0.16

[Francois-Rene Rideau]

   I must leave again for a few weeks to focus on my exams.
I'll still be around to help with project organization and/or merge your
modifications (if any), but I won't personally contribute during this time,
and would always be glad to delegate the organization that I never wanted
to do anyway.

   I'm releasing my latest changes as 0.0.0.16, so that there be less merging
problems; no great modifications were done since 0.0.0.15 (see Changelog.html).
BTW, I also published patches for this version, as well as patches for the
older versions.

   There are *lots* of work to do, which could very well be done by different
person on a weekly synchronization basis. Help is really welcome, but I've
been mostly the only one to contribute :( :( :(

------>8------>8------>8------>8------>8------>8------>8------>8------>8------
*** Here is the status of the various subprojects: ***

* Root Project:
   The FAQ should be refined.
   The project should be made more attractive to the potential contributors,
and advertisement be made about the project.
   There should be a way to have project members actually do things in the
project !!!


* The Review Subproject:
   There sure are a lot to do. I've thrown a lot of ideas there,
but I've not finished writing any single article. Perhaps you could
continue what was begun, write new stuff or at least suggest how to
enhance/modify what's there ?
   This project was meant to be everything one wanted that one couldn't
have on existing systems. Now that the project began, have you members
nothing left to complain about existing systems ?


* The HLL project:
   I've continued to look at existing languages, and still have not
found any one to fulfill half of our requirements.
   There are ideas and difficulties in the HLL pages, but I admit the HLL
project has not advanced much.
   I propose we define some generic way to define and use higher-order
modules (i.e. you can define objects, but also meta-objects/grammar rules/
defining words, etc). Then we can have some simple languages (FORTH, Scheme,
SELF) implemented as simple modules.
   As we intend to provide correctness proofs, I propose we use Haskell or Coq
as a basis for the high-level syntax...
   However, to develop a language, we need feedback from actual programs
written using the language. We should really design applications while
defining the language.
   If you have anything that is you think particularly good or bad about
some existing language, please send an example, so that we write a library
of such things. Theoretical requirements is a must, but practical examples
are needed, too...


* The metatranslator subproject:
   This ones haven't advanced at all. They are waiting for the HLL to appear.
Well, the metatranslator should begin with some ad-hoc HLL compiler written
in LLL, and refined into more and more abstracted independent modules being
assembled together.


* The C translator subproject:
   This one is almost empty. There are chances next year I begin some PhD
thesis about partial evaluation in C, which I could relate to this
C translator subproject...


* The Interfaces project:
   This one hasn't advanced much. Chris ?
   There is lots of work that can be done currently:
define the actual way intelligent input/output will be done
(that is not only static ways of doing I/O, but dynamic ways, with
editable history, higher-order rewrite, etc) , HLL syntax,
help with the CD Database example, etc.


* The Migration Subproject:
   Unhappily, not much is possible here until we have some underlying LLL
system implemented. Still, we could define portable encodings of objects,
as well as begin to plan what first mechanisms to implement. We should also
review existing distributed computing projects...
   Also, the LLL will firstly implement only the most trivial kind of
migration: saving/restoring an image of memory, all the rest being explicit.
The migration subproject should write more subtle migration stuff in LLL or
HLL (which is a good question - any good argument for an anwser ?).


* The LLL project:
   The initial "kernel" should be minimal, basically just a FORTH core
without compiler, with a minimal I/O subsystem, and a simple dynamic loader
module able to read just one format we choose or design.
   Also there lacks some agreement on what object encoding to use.
   This one needn't much more specifications to advance, just discussion
between implementers. Will anybody help coding ? 


* In the OTOP subproject:
   As POSIX systems vary a lot, we need some automatic configuration
system. I propose a mix between the caml-light and the pfe ways.
Anyone willing to manage that ? See "OTOP/OTOP.html#implementation ideas".


* In the i386 subproject:
   Also, I've been studying the possibility of porting some FORTH-based
i386 assembler to speed up bootstrapping of the system: it would generate
itself !


------>8------>8------>8------>8------>8------>8------>8------>8------>8------
Note: it would be a good idea to maintain some permanent "status"
page like this in the project, or perhaps merge that to some existing
page. Which ?

--    ,        	                                ,           _ v    ~  ^  --
-- Fare -- rideau@clipper.ens.fr -- Francois-Rene Rideau -- +)ang-Vu Ban --
--                                      '                   / .          --
Join the TUNES project for a computing system based on computing freedom !
		   TUNES is a Useful, Not Expedient System
WWW page at URL: "http://acacia.ens.fr:8080/home/rideau/Tunes/"