what is the point of open implementation?
why object is root of inheritance?
why Class is inheriting from Object
why Class is instance of itself?
why Object is an instance of Class?
why a metaclass counting the instance created inherits from class and is
instance of Class?
what is introspection versus reflection versus intercession?
why is there a problem when composing metaclasses?
what are the two kinds of problems where composing metaclasses?
what is the differences between reflection and open implementation?


Stef

----------------------------------------------------------------------

Here are my answers.  Not sure what you meant by a few points.  Please check.

Oscar

> what is the point of open implementation?
- enable language extensions
- finer degree over policies (e.g., when does garbage collection kick in)

> why object is root of inheritance?
- everything is an object
- one place to define all common behaviour and state

> why Class is inheriting from Object
- everything inherits from Object (all classes)
- instances of Class are also Objects

> why Class is instance of itself?
- classes are objects too
- every class is an instance of Class, including Class

> why Object is an instance of Class?
- Object is also a class, hence an instance of Class

> why a metaclass counting the instances created inherits from class and is
> instance of Class?
- a metaclass is both an object and a class, hence is an instance of Class and inherits from Class
- it is a new class, because Class does not offer the capability to count instances

> what is introspection versus reflection versus intercession?
- introspection reifies meta-level knowledge as objects and lets you act on
- reflection lets you modify reifies meta-data and reflect it back into the behaviour of the system

* intercession?!

> why is there a problem when composing metaclasses?
* huh? what does it mean to "compose" metaclasses?

> what are the two kinds of problems where composing metaclasses?
?

> what is the differences between reflection and open implementation?
- reflection: reify and reflect meta-data
- open implementation: provide a MOP

----------------------------------------------------------------------

>> what is the point of open implementation?
> - enable language extensions
> - finer degree over policies (e.g., when does garbage collection kick in)

Being able to customize certain aspects of a system. Parts that are normally hard-coded. 


>> why object is root of inheritance?
> - everything is an object
> - one place to define all common behaviour and state
For object there is no state. Only a pointer or ref to its class, it depends
on the VM implementation but nirmally object reference to its class is not
an instance variable but treated by the VM directly.

> * intercession?!

In fact reflection = intercession + introspection

intercession = your reflection definition
 
>> why is there a problem when composing metaclasses?
> * huh? what does it mean to "compose" metaclasses?

If a class A instance of metaA inherits from B instance of MetaB then we are
in trouble because metaA and metaB may not be in inheritance relations.

I suggest you to read the beginning of the paper safe metaclass programming.
This is extremely well explained. The paper is available with all the paper
I gave to read.

 
>> what are the two kinds of problems where composing metaclasses?
> ?

see the paper too boring to write them.

> 
>> what is the differences between reflection and open implementation?
> - reflection: reify and reflect meta-data
> - open implementation: provide a MOP

Yes so only open certain part.