More Slate promises...

[RE01 Rice Brian T. EM2]

To the most patient language enthusiasts I know of... :)

I am in the middle of a busy month with little to no internet access,
although I now have a machine that runs Self 4.1.2, and am thoroughly
exploring the ideas there and in the various Lisp and Forth flavors.

I am also trying to write some very detailed accounts of my ideas about
Slate, particularly the meta-object facilities, evaluation scheme, and
particularly explanations of how the Slate ideas evolved from Self, Lisp,
Beta, and Forth, with examples and such. I am not allowed to send the files
I am working on over this mail account, so it will be another two weeks
before I can upload. But you should expect a fresh start for the Slate site
documentation and some Squeak code demonstrating the ideas.

Just to reminds people, some big points about Slate over Self are
	(1) the persistent object graph traversed by slot names
		(trivial syntax which allows for meta-programming),
	(2) the object-metaobject distinction (factoring),
	(3) an extensible, multi-aspect metaobject architecture,
	(4) making explicit the use of reverse namespace access
		(the former ".." slots now known as "<"),
	(5) the removal of slots which evaluate automatically
		(methods are not meta-objects),
	(6) assignment is subsumed by dynamic inheritance,
	(7) mutability is controlled at the meta-level and provides a lot of
levels of control.

Probably one of the first interesting exercises for a mini Slate system
would be to provide a kind of syntactic extension to Slate to provide
something like Self's slot-initialization features. However, in this case,
such would be provided by objects within the environment, using the
concatenative syntax to "simulate" the expressions in the language
extension.
For example, "( | x = 10 | )" (to take a cheap Self example) would take a
"(" slot in the starting namespace, then "|" within that. After that,
something interesting happens... "|"s meta-object steps in on the lookup
phase to provide an "x" object with the appropriate semantics: a
construction object that continues the process until the expression end is
denoted, when the whole object chain evaluates into the desired object.

This concept is familiar to advanced Forth users as meta-compilation,
although Forth only shares the trivial syntax with Slate, not the semantic
structure. So in Forth you type in words in sequence that "look like" the
target language expression, but in Slate, the same is done by building an
object graph with annotations that evaluates into the equivalently-behaving
Slate objects.

I promise to get to answering the questions you have when I get back.

Thanks,
~