[Grace-core] Minutes of Telecon 23-24.2.2014

[James Noble]

Overall, we had an USEFUL and CONSTRUCTIVE discussion about INHERITANCE!

We didn't resolve to a design, but we did come up with some key questions:

* safety of field initialisers
 - is the "uninitialised field exception" enough?    (plus dialects for additional static checking)
 - if so, is the core language strong enough for us to write those dialects?
 - if not, how much more restrictive do we want to be
ACTUALLY UFE SHOULD BE ENOUGH!  (but we may have to reopen the whole issue)

*** consistency of Self during creation & initialisation  AKA  delegation vs inheritance /"concatenation"
 - can "construction or initialisation code" make downcalls that a resolved to subclasses
 - can you refer to self in "construction or initialisation code"  (e.g. to register a widget) 
 - in what way should the semantics of "construction & initialisation code" differ from "straightline" code
 - how obvious is it that the delegatee (superobject) can be constructed (long) before the the delegate (subobject)
NEED TO THINK ABOUT 
 - JAMES to write 
 - KIM / ANDREW / TIM? - to look at OD w/ delegation

* combination of dialects
 - is it enough to combine dialects by first combining "traits" and then instantiating the combination? 
  - Michael - not if they have checkers...
NEED TO THINK ABOUT 

* multiple combinations
 - we do need some way to combine multiple things - YES
 - how flexible should that combination be?
    - stateless vs stateful? 
    - do we need "directed resends" or something to choose in code
    - if we do how should that be provided: in code, or in a trait algebra

* fundamental underlying object model
 - static vs dynamic objects  (add/remove fields/methods) - NO
 - static vs dynamic superclasses? (superclass can be a parameter) - STATIC?
 - how many kinds of objects? how many kinds of links? how complex are objects?
 - how nixonian?

* do we want some better mechanism for lazy initialisation?

* up vs out problem