Hello all,

This is my first release announcement of Slate on this mailing list,
although I've alluded to it many times and discussed it individually with
quite a few Squeak users. I've been hesitant to announce it since
Squeakers have high standards when it comes to an environment, especially
for something like Slate which aims to be a lot like Squeak, even if only
by learning lessons from it.

So, here's the short of it:

Slate is a "clean slate" Smalltalk; the purpose of it is to provide the
most powerful and yet simple language that can possibly be easily
recognized as Smalltalk-compatible. So, Slate includes prototype-based
object programming, using multiple arguments to define a method's
signature, instead of just the first. We currently use Self's delegation
slots for inheritance, although at some point in the future we will
provide something more class-friendly, after having learned how the mix of
mechanisms best works.

And then, there are the really powerful libraries we've been building with
it over the last year and a half. Craig Latta's Flow framework is included
and even extended in Slate, the collections are quite enhanced themselves,
with much the same ideas as in the Traits project, the exceptions are
enhanced to have object-oriented restarts (handlers), and many many other
small details that accumulated sometimes without planning into a new
powerful possibility.

We have some interesting new language experiments which may interest
people here, such as subjective programming (somewhat similar to PIE and
other related ideas) and optional keyword arguments or positional
arguments (done without C-style syntax). There is also a syntactic
abstraction support built in to the language, which seems on first glance
to be contradictory to the Smalltalk way of doing things, but actually
makes good sense when you take the time to understand it.

With all that said, Slate is not ready for prime-time, being written in
Lisp (with an inlining compiler, but still), and not having the full kind
of access you get with a dedicated VM. 0.2 to 0.3 will consist of shifting
to a Squeak-style VM implementation, although my dialect for the
C-translation is a lot easier to work in, I believe.

The upside is that we've taken great care to document everything in a
reference manual and add comments to nearly every method and area of
definition. This is of course necessary in any new work, but we're
particularly keen on ensuring that there's no mystery in the system.

Slate's environment right now consists of a command-line semi-compiler, a
debugger, inspector, and Emacs interaction mode with source highlighting.
Slate images can be saved and restored transparently through the host Lisp
system. There is a graphical system whose bare functions may be tested if
one is handy with Lisp, but otherwise it is not for use until 0.3 or 0.4
fully support it.

Slate's website is http://slate.tunes.org/ , and the 0.2 release is
announced there and available under the Downloads section. Slate is
MIT-licensed, and whenever we patterned some source after another's
library, we cited them in the comments; all such libraries were similarly
freely available.

Feel free to ask questions, but I am not going to make any stance on
policy about Slate vs. Squeak, except that I personally consider it more
worthwhile to develop the largest-scale improvements to Squeak in Slate.

PS: This obviously is a lot of information to digest. There is quite a
set of materials for learning the basics on the site, and the reference
manual is meticulously updated by yours truly, so make good use of them.
:)

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