RScheme

[Fare Rideau]

Dear Donovan,
   I'm interested in building an reflective operating system,
integrated within a high-level language, and featuring a persistent store.
>From what I read about RScheme, it might very well be
a good starting point for my coding (other people with different projects
are wondering the same on the LispOS mailing-list).

However, there are several points that I'm worried about:

* how "modular" is the system? That is, how easy would it be for me
 to steal parts of it, so as to mix-and-match with other code I'd write
 (or steal from other people)? There does not seem to be any ROADMAP
 for newcomers to understand what files correspond
 to what parts of the system, and which parts rely on which other parts.

* so that the system can develop itself in a standalone way,
 and ability to store classes and native code in the persistent store,
 without having to resort to a file system; classes ought to be
 fully first-class objects, not associated to a global name.
 However, I understand that the current RScheme system does not
 allow that. Would it be possible to add it, or would I be better off
 starting from scratch?

* another things that would be useful are first-class environments
 and a few other things that MIT-Scheme provides, so as to port edwin,
 if possible.

* So as to allow both efficient real-time processes and orthogonally
 persistent (perhaps distributed) data, I intend to split the heap
 into several zones with different priorities and policies,
 which means different code-generation (or interpretation) tactics,
 and indirect communication between real-time and distributed parts.
 Actually, I intend to annotate types with extra information bits,
 such as linearity, modifiability, real-time accessibility, etc.
 For security and resource monitoring purposes,
 having separate yet communicating heaps (e.g. one per "user")
 would also be good.
 How would that fit or not in the RScheme runtime and compiler?

* So as to allow users to control what happens before the system may crash,
 I need some way to monitor the way GC and persistence are done,
 considering that if the system starts eating to much memory,
 the system should not fail or swap to death, which would be all the
 more damaging that persistence of processes would have the same
 behavior appear back after reboot!
 Is such thing doable from the RScheme GC and store?

* If not RScheme, which existing system would you advise to steal code from?

* Do you know anyone interested in building such a system?


Other minor questions/remarks about RScheme:

* minor notes about tech.ps:
 2^29 is not rendered correctly on page 1;
 two-bytes should be four-bytes on page 5;
 [I'll send more feadback as I re-read the docs carefully]

* What happened to the old texinfo documentation?

* What does the R in RScheme mean?

* Is Prof. Paul Wilson still taking active part in the development of RScheme?

* I once mailed to Prof Wilson about a technique of generating
 safe-point-recovery code together with optimized native code,
 so as to be able to combine GC with reactive preemptive multi-threading,
 but received no response. Has the technique ever been considered?
 or was discarded because it wasn't effective, or because it costs too much,
 or just because Prof Wilson doesn't have time?
 I understand that the technique is not effective when compiling to C,
 since the C compiler's optimizations prevent recovery, unless they are
 disabled (with volatile variables and other serializations),
 which defeats the purpose.

Thanks for all, congratulations for your code, and best regards,

## Faré | VN: Уng-Vû Bân   | Join the TUNES project!  http://www.tunes.org/ ##
## FR: François-René Rideau |    TUNES is a Useful, Not Expedient System     ##
## Reflection&Cybernethics  | Project for a Free Reflective Computing System ##
Does either tradition or innovation add any value to anything per se?
Do you buy your soap because for its new enhanced formula,
for its well-known old brand, or for its washing properties?
		-- Faré