[Uml-devel] CASE tools and IDEs

[Andrew Sutton]

On Wednesday 29 January 2003 11:59 am, Sebastian Stein wrote:
> >  ...
>
> This describes very well what I'm thinking about IDEs and CASE tools. Thank
> you Andrew!

ain't no thing :)

why, for the love of god, did the OMG have to make these standards so hard to 
wrap your head around. i've been beating my head against this stuff for the 
last weak trying to figure out how to implement the lifecycle semantics in a 
general way so that its applicable for both MOF and UML - because they both 
derive from the reflective interfaces. its driving me insane - not to mention 
building adaptation interfaces into the reflective interfaces so we can adapt 
UML and MOF and CWM and whatever other metamodels we feel ambitious enough to 
implement to the reflective interfaces. i think the OMG is playing a cruel 
joke on us.

agh... extents and lifecycles. damn them. damn them!!! of course, non of this 
would be overly complicated if i gave up trying to figure out how to build 
the ultra-generic XMI parsing algorithm - i think i have it figured out.

anyway, here's what i'm figuring out:

an extent is something that absolutely contains instances of something else. 
we deal with 3 types of extents: package extents, association extents and 
class proxies (basically a factory interface). the outermost extent is 
really, really important and is always derived from RefPackage. it contains 
instances of all other nested and clustered packages that are imported. it 
also contains instances of class proxies and associations defined within that 
package.

for MOF, the outer most package is Model:Package. for UML, it can be either 
UML:Package, UML:Model or UML:Subsystem (Model and Subsystem derive from 
Package). Each of this is implemented by a class with the name "Package" 
appended to it and provides accessors for all the extents it instantiates. 
The reflective interface allows generic access to those extents based on the 
name - in otherwords, given a RefPackage reference, you can lookup the class 
extent and instantiate it using the RefClass::create() interface. working 
with associations is quite similar - actually, its a little easier (which 
surprised me).

i think the adaptation of any metamodel (MOF, UML, CWM, etc.) is going to boil 
down to implementing various concepts that are required for adaptation. i 
think what's really driving me mad is what those concepts are and how they 
might be defined, much less implemented. here are the concepts of come up 
with:
- scope resolution - this deals with immediate and outer package methods on 
RefBaseObject.
- meta object identification - i still don't really know alot about this. its 
very, very confusing to me. i think it will always boil down to returning the 
metamodel object from which the instance was created. for MOF and UML objects 
it will almost always be Model::Class, Model::Package or Model::Association. 
don't quote me on this though :)
- containment resolutions - the immediate and outer composite. i'm not sure 
what the difference is between composition and scope. i think composition 
deals with instance containment where scope deals with classifier 
containment.
- factory - actually pretty simple. class proxies for non-abstract classes 
provide a create() method that instantiates an implementation object.
- class - also pretty simple. An instance of an object returns an instance
to the class proxy from which it was created. notably different than 
meta-object identification.

there's a bunch more. i'm trying to pick through these and figure out which 
concepts can be implemented generically and which require additional code. i 
fear that i'm not doing a great job at it. anyway, that's why i'm late 
handing this mass of code off to anybody :)

andy