RE: [SE] Suggestion of new note

Michael,

>See inline comments.
>
>============================================
>Mike Uschold
...
>>  Some comments
>>  
>>  Regarding slide 2:
>>  
>>   Object models (e.g. UML 1.x or precursors) support multiple 
>>  inheritence. Even 
>>   when disjoint subtype coverings are specified, an instance 
>>  can have multiple 
>>   types (it's instantiated type and each supertype of that type).
>
>I guess there may be a distinction between UML and object-oriented
>software development in general. My understanding is that traditional
>object models:
>* only allow strict taxonomy, a class cannot have more than one direct
>superclass
>* an instance can only be a direct member of one class, it is an
>indirect member of all that class's superclasses, by inheritance.

The features present in an OO programming language is not standard.  When I was
trained in OO programming (early 90s), multiple inheritence was included and 
C++ supported it.  I don't remember it being banned in CORBA either (not an
OOPL, but very much OO-based).

If you mean to refer to JAVA language features (and I don't know that you do), 
then you should explicitly state that.  JAVA narrowed the set of features that
were in prior OO languages.  It's not only multiple inheritance that it left out,
operator overloading was also largely unsupported (and a pretty basic OO feature
in my book).

One reason I focused on UML was the use of the term "object
model" in these discussions.  For me this refers to a model defined using an object 
modelling formalism such as OMT, UML, etc.  These days, UML is the standard language 
for such models.  UML 2.x has evolved beyond this role a bit, that is why I said UML
1.x and precursors (well that and the fact that the UML 2 specification inscrutable).

>It may be that UML 1.x goes beyond this limitation. Is this correct?

UML has allowed/supported multiple inheritence since at least the UML Language
Reference Manual which predates UML as a standard (UML 0.x).  The direct/indirect 
instance stuff is an implementation thing that I haven't seen any words about in the UML
specifications.  I don't think that the indirect-direct distinction is important in 
most uses of instances in OO, in fact the lack of this distinction is where the most basic
powers of reuse are derived in OO.  

The important distinction around this area for me for the OO and OWL comparison is strong 
typing versus weak typing.  Any instance (Object) in an OO system (even in a UML repository) 
must have a corresponding "complete" class definition in the model from which it is derived.  
By complete, I mean it describes every attribute value and relation that the object may have.  
It is for finding or using this complete description that we need to know an object's direct 
instance value and that only happens at major object life-cycle events like creation, 
destruction, and maybe serialization (if supported in your OO environment).  In OWL and RDF,
of course, there is no requirement any such comprehensive description.  Individuals may take
on values for properties not mentioned in any class description.

>>   Associations (relations) are defined with respect to 
>>  particular classes at their 
>>   AssociationEnds.  Thus Associations are attached to one or 
>>  (usually) more classes.  
>
>This means an association is very much like an OWL property (relation).
>Is it true that an association is just like an OWL property, in that it
>stands alone separate from any particular class, and the association
>ends are exactly analogous to domain and range constraints? Are there
>any important differences? What are they?

UML Associations (in UML 1.x) ARE defined in terms of the classes that they relate (i.e.
the one at the AssociationEnds). The point of my previous comment was only that they usually 
relate more than one class, not that they were first class entities like properties in RDF and 
OWL.  This notion of free floating properties can be difficult for UML people.  Having said 
that however, a typical binary Association could be said to correspond to an RDF Property with 
an implicit inverse Property and where each of the domain and range are defined in terms of a
named class or datatype.

-Evan

Received on Wednesday, 5 October 2005 21:04:15 UTC