Interim Update

[Brian T Rice]

Hello again.

Please bear with the recent lack of communication and visible development
around Slate. We really are still here, behind the scenes, working on it.

I've been dealing with some difficult financial times recently, which has
slowed things down and complicated my life, but things should be looking
better soon...

As to development specifics, I've been working on things outside of the
CVS repository, so none of it's visible yet, and it will all be merged in
via a large batch operation just before 0.2. Currently, I'm working on
several projects, each of them significant, and 0.2 will be the first
truly useful Slate version. Here's an overview:

- Refactoring of the streaming framework to handle external resources
relatively uniformly. This gives a structured framework into which
sockets, files, pipes, the console and many other things fit. This also
sets us up for a more easily extensible implementation via Slate->C for
reasons that can be explained later. It's based on the Squeak-related Flow
framework by Craig Latta, for those who know, but also goes beyond it by
quite a bit, since this is a more powerful language and offers some
interesting opporunities which I'll point out.

- Focus of the release format for interactive shell use. This means that
ECL is being abandoned due to its odd platform idiosynchrasies in favor of
CLISP, the bytecoded Lisp that has shell capabilities and is highly
cross-platform and relatively compact. The Slate environment will feature
a lot of enhancements to access these functions. 0.2 will essentially be a
"shell release", focussing on making it useful within that context.

- Refactoring the primitives to an absolute minimum set. This will make
the rewrite in Slate for C-translation much more clear of a path.

- Filling out the condition system implementation and adding concurrency
support. This will obviously allow for a lot more robust code. For the
concurrency code, I'm using a system simimlar to Smalltalk-80 processes,
but skipping Semaphores and using a Linda-like Monitor framework authored
by Nathanael Schaerli, also related to Squeak.

- A system for saving out and loading the whole heap (and object groups if
I can find the time). This will be experimental, but should allow some
more interesting shifts in development to take place, and avoid some long
build times. At the very least, it will expose design problems that we
aren't currently dealing with, like how to declaratively deal with
recompiling a library, and other similar issues.

- The Slate->C translator will be completed so that basic programs can be
written in C using Slate. This will be proof of concept for the 0.2
release, but it and the Slate VM implementation in Slate will be the focus
for 0.2 to 0.3. The Slate-in-Slate VM will be provided in its current
state, largely incomplete, but giving a good idea of the overall direction
and some examples of how the translator can be used.

This sounds like quite a lot when I explain it this way. Most of it is
done, but there's still some work left. When I do perform tha batch
update, I'll try to include as many notes as possible, and I am updating
the manuals to cover this. I'll also create an additional tutorial for the
libraries, since they're already becoming large enough that a simple
reference won't do. Anyway, let us know if there's some change you're
interested in, or some question about our intentions or state of progress
that isn't too clear.

-- 
Brian T. Rice
LOGOS Research and Development
http://tunes.org/~water/