[Grace-core] towards a release of the specification

[James Noble]

Hi all

so talking to people here (and as I've been travelling around)
I've found myself saying "we're working towards a new version
of the spec, and that I hope it'll be ready by ECOOP" - basically
the end of June.

so I figured we should at least discuss that :-)

the main thing I think that needs to be done regarding the actual
spec is mostly to clean up what's there (pattern matching)
bringing it up to date (dialects, modules), and being clear about
what we don't have quite yet  (typechecker, libraries...) 


there are (at least) two more substantial things that would help.

FIRST talking to Tijs van der Storm, he'd like a better grammar,
particularly one that handles the formatting (offside) rule
that we use.  The current one is OK if not ideal, it needs to be
updated for annotations, dialects, etc, but it doesn't handle
the formatting rules at all.  I think there are two tasks here:

 * find a clearer specification of the layout rules we use

 * find a good way to incorporate them in to the parser-combinator
   grammar (or otherwise find another/better grammar specification :-)

there have been papers on doing layout parsing at POPL & SLE 
recently (apparently the SLE paper is ... more robust) but I don't know
of any work about doing layout nicely with parser combinators.... Andrew? 



SECOND, coming out of my visit with Kim, and also talking to e.g. Joe Kiniry,
it would be good to have at least a specification of the operational semantics
of Grace - partly so we can argue properly about features (like inheritance)
and partly so we can have a better idea about how things like e.g. 
receiverless requests are resolved.  This would also guide us towards
a "canonical" / "abstract" version of the AST that could be used for
checkers and not tied so tightly to details of minigrace.   

What Kim & I thought about doing was a "definitional" self-interpreter in 
Grace - a clear high-level description of Grace's execution written in Grace.
(and presumably eventually runable on minigrace, although this kind of 
thing must be written to be read, rather than run).   Self-interpreters
are common in  the LISP world; the Smalltalk BlueBook had one
(more or less, it was a bytecode interpreter) but they don't seem to
have been done for OOLs for a while. This hasn't been done for
Newspeak or Scala or gBETA (I think) -- there are calculi
but they only address small cores of languages and are mostly about
type systems. We've all of two weeks until the DLS deadline.
So this could be interesting in its own right, and a step
towards a more formal operational semantics.

But so far Kim and I only made a very small start,
focusing on object literals & inheritance,
there is a file in the claremont directory in the SVN. 

thoughts? 

cheers

James