Below are the transcribed notes I (dnm) took on Slate during a relatively
in-depth conversation about its aims and its design with Brian Rice (water)
on IRC back in February of 2002.


D. Moniz
2002-02-16
(Transcribed on 2002-05-03)

Notes about Slate:

Concepts:
    - Objects
    - Meta-objects
    - Graph manipulation
    - Term rewriting
    - Postfix syntax with bracket and paren delimited code blocks

Models:
    - Self: objects as environments, prototypes, lightweight UI, directness
    - BETA: objects with unified procedures, modelling, controlled inheritance
    - Joy: concatenative syntax, open implementation, reader function/macros
    - Forth: meta-compilers, tiny and simple implementation, otherwise 
      superceded by Joy
    - Lisp: syntactic abstraction, open implementation, reader function/macros

Questions and Answers:

1. What is Slate's purpose in life?

To provide for implementation of TUNES requirements that aren't already met,
and to provide a language that is more hackable and extensible at lower layers
than is currently allowed (e.g. at the lexical level).

2. Can this be accomplished with an existing language with less work?

Existing languages like Lisp or Forth could be used, but aren't sufficiently
well-put-together in the sense of having single abstractions equally usable
for multiple types of system entities (e.g. environments).

3. What does Slate bring to the table that other languages don't have?

Slate centers around a basic data abstraction (the not-necessarily-finite map)
which can be realized in many different ways, and which provides orderable
structure and lexical tie-ins.

4. What will Slate be implemented in and why?

Common Lisp, because it has very good hooks included e.g. for reader functions
and parsing, and it has industrial implementations with garbage collection and
a good development environment.

5. What is the _minimum_ set of abstractions that Slate will _need_ to have
inherent in its design in order to achieve its goals, taking the above into
account?

Maps, meta-objects, bootstrapping literal types like characters, hardware
integers, bit-fields, and such. However, the literal types could be shifted to
a source based implementation later if a good Slate compiler became available.
The evaluation primitives are not yet specified, however, but would preferably
be a small set of well understood behaviors to be combined safely into
interesting commonly-know behaviors.