[Grace-core] Minutes of Teleconference 2-3.8.12

[James Noble]

We talked mostly about inheritance, a little about dialects
 
 * Delegation is strictly stronger than concatenation - because 
      concatenation can be simulated by delegating to a (shallow) copy
       (from Michael "Mr Literal" Homer) 

 * Reiterated from last week: PICK TWO:
  1. "classical" inheritance semantics - "self" bound to sub-object while super-object literal executes
  2. inheritance from an arbitrary object
  3. a simple explanation of classes in terms of objects

 * James can see three options more or less solidifying
  -> delegation (possibly concatenation, but delegation looks stronger now
  -> inheritance only from classes (but how do we elaborate classes - multiple constructors, static state, etc)
  -> (potentially) "factory method" support -- James to write up
 
 * James wrote out a list of inheritance use cases below 

Andrew, James & Kim are supposed to write "manuals" on their inheritance semantics

James typed up a list of use cases for inheritance - what people want to do
  (which may or may not be directly supported by language constructs) 

Michael will submit the Onward! paper

Tim will write up something about dialects

Next call 9-10 August




Inheritance Use Cases

(see also https://projects.cecs.pdx.edu:8443/~black/NewOOL/index.cgi/wiki/InheritanceReAnimated
for a list with numbers that is *impossible* to paste into anything and keep the numbers!! )
		• adding methods to new subclass instances
		• overriding methods
		• adding fields to instances (copy down fields)
		• overriding accessor or mutator of superclass field
		• free-standing initialization code
		• initializing defs / final fields
		• registration (in a superclass) --- e.g. register a widget with current window
		• top-level code blocks e.g. --- e.g. invariants
		• adding alternative constructor methods
		• class side state --- e.g. an instance counter
		• inheriting superclass constructors (without overriding)
		• write a cloning method in a subclass - reusing superclass definition
		• creating an instance of a (default) class that satisfies an interface