[Grace-core] SPLASH, Grace, etc

[James Noble]

Hi Doug

so a quick email, since I was hoping to catch up
with you at SPLASH a little more than I did.

partly to say thanks for talking at ECOOP (again)
it was certainly a fruitful conversation:

also to ask for a bit about one of those fruits - the Grace effort.

Currently, we're planning on *not* addressing concurrency or  
parallelism in the "base language"
with the idea that we don't really know what to do, so different  
options (actors, locks, STMs, CASes)
would be supported by a library.  I'm wondering how feasible that  
approach really is:
I'm hoping it is at least reasonably sensible...

Assuming it is: what other language features should we emphasize in  
the core language
that may not directly support concurrency but will be useful later on?
- value objects ("deeply immutable")
- Eiffel "once" /Scala style "lazy" variables (lazy initialisation)
- lambdas  (good for libraries)

those three are currently in the list. Things that aren't include:  
uniqueness
or ownership, real pass by reference, "value semantics" (C++ style)...

Alternatively, what features are we going for that may make things  
more difficult?
  - arbitrary number types rather than neat machine ints and floats?
  - everything boxed by default
  - lambdas? (the current design has Grace using it's lambdas pretty  
much
           where Smalltalk uses blocks. That is, almost everywhere)

We hope to start updating the grace blog with notes on some language
design features in the next few days (i.e. once

James