Multi Level Modelling precise | role based | modular | simple

1. Multi-Level Modelling
precise | role based | modular | simple

2. A typical problem

3. object oriented model A object oriented model B
(modelling instantiation via association) (modelling instantiation via specialisation)
Class : Mammal
Class : AnimalSpecies Class : Animal
[2] dateOfBirth
maxAge dateOfBirth
[1] [*] problem
no species
[*]
data
A.S. : Dog
{20 years} Class : Dog Class : Cat
isPoliceDog [2] [2]
A.S. : Cat
{30 years} [*] [*]
Dog : Jack Cat : Coco
Animal : Jack Animal : Coco {1/5/03, yes} {4/3/07}
{1/5/03} {4/3/07}
Dog : Susie Cat : Peter
Animal : Susie Animal : Peter {1/2/00, no} {10/9/98}
{1/2/00} {10/9/98}
problem
no species-specific
instance data problem
precision of links

4. object oriented model C
(Power Type pattern)
Class : Mammal
Class : AnimalSpecies
dateOfBirth
maxAge [1] [*]
problem
Fragmentation of
concepts
A.S. : Dog
{20 years} Class : Dog Class : Cat
isPoliceDog [2] [2]
A.S. : Cat
{30 years} [*] [*]
problem
Spurious complexity
Dog : Jack Cat : Coco
{1/5/03, yes} {4/3/07}
Dog : Susie Cat : Peter
{1/2/00, no} {10/9/98}

5. object oriented model C design time
(Power Type pattern)
Class : Mammal
Class : AnimalSpecies
dateOfBirth
maxAge [1] [*]
configuration
A.S. : Dog
{20 years}
time? Class : Dog
isPoliceDog [2]
Class : Cat
[2]
A.S. : Cat
{30 years} [*] [*]
Dog : Jack Cat : Coco
{1/5/03, yes} {4/3/07}
Dog : Susie Cat : Peter
{1/2/00, no} {10/9/98}
run time

6. The solution

7. multi-level modelling Vertex : AnimalSpecies design time
maxAge
precise instantiation semantics isAbstract : no
role based binding times
modularity
simplicity
AnimalSpecies : Mammal configuration
maxAge : 150
isAbstract : yes
dateOfBirth
time
AnimalSpecies : Dog AnimalSpecies : Cat
maxAge : 20 [2] maxAge : 30 [2]
isAbstract : no isAbstract : no
isPoliceDog [*] [*]
run time
Dog : Jack Dog : Susie Cat : Coco Cat : Peter
dateOfBirth : 1/5/03 dateOfBirth : 1/2/00 dateOfBirth : 4/3/07 dateOfBirth : 10/9/98
isPoliceDog : yes isPoliceDog : no

8. multi-level modelling Vertex : AnimalSpecies design time
maxAge
precise instantiation semantics isAbstract : no
role based binding times
modularity
simplicity
instantiation ...
AnimalSpecies : Mammal configuration
establishes connections between
two levels of abstraction that
define different binding times
maxAge : 150
isAbstract : yes
dateOfBirth
time
a consistent instantiation
generalisation/specialisation ... mechanism at all levels
expresses the commonalities and & unlimited levels of
variabilities between the concepts instantiation
relevant to a specific binding time AnimalSpecies : Dog AnimalSpecies : Cat
maxAge : 20 [2] maxAge : 30 [2]
isAbstract : no isAbstract : no
isPoliceDog [*] [*]
run time
Dog : Jack Dog : Susie Cat : Coco Cat : Peter
dateOfBirth : 1/5/03 dateOfBirth : 1/2/00 dateOfBirth : 4/3/07 dateOfBirth : 10/9/98
isPoliceDog : yes isPoliceDog : no

9. The technology

11. isAbstract Graph : Graph
isAbstract = TRUE
OrderedSet :
EdgeEnd : subSet[1] Edge : # SuperSetReference :
SuperSetReference
Gmodel
OrderedSet Edge : # isAbstract = FALSE EdgeEnd : artifact[1]
*
OrderedPair : EdgeEnd : EdgeEnd : Edge : #
OrderedPair superSet[1] SuperSetReference
Flavored[*]
EdgeEnd : commands[*]
Link : Link
Edge : #
EdgeEnd : isAbstract = TRUE
queries[*]
Edge : #
Visibility : Visibility Edge : # EdgeEnd : toSubGraph[1]
EdgeEnd : propertyDefinitions[*]
Edge : # EdgeEnd : fromSubGraph[1]
Edge : #
isAbstract = FALSE
EdgeEnd : propertyValues[*] EdgeEnd : artifact[1]
Edge : # EdgeEnd : Edge : #
EdgeEnd :
visibilityFlavored[*]
vertex[1]
beyond Open Edge : #
Source
Edge : # EdgeTrace : EdgeTrace EdgeEnd : artifact[1]
EdgeEnd : semanticIdentity[1]
isAbstract = FALSE EdgeEnd : Edge : #
Vertex : edgeTrace
SemanticDomain.SemanticIdentity Flavored[*]
isAbstract = FALSE
Edge : # Edge : #
EdgeEnd : EdgeEnd
EdgeEnd : abstraction[1] EdgeEnd : detail[1]
minCardinality
maxCardinality
Edge : Edge
isContainer EdgeEnd : artifact[1]
isNavigable Edge : # isAbstract = FALSE
isAbstract = FALSE EdgeEnd : Edge : #
EdgeEnd : edgeEnds[2] edgeFlavored[*]
EdgeEnd : artifact[1] EdgeEnd : vertexFlavored[*]
Edge : # Vertex : Vertex
isAbstract = FALSE

12. The following pages illustrate the use of the
Gmodel API.
For further information on the
open source Gmodel technology
based on denotational semantics,
contact:
Jorn Bettin
jbe @ sofismo.ch

13. Examples

14. Vertex : DomainAnalysis
Vertex : ProjectManagement
Vertex : ProductManagement Vertex : ApplicationEngineering
Vertex : ProductLineManagement Vertex : DomainEngineering

15. Vertex : DomainAnalysis
Vertex : ProjectManagement
Model expressed through the Gmodel API
Instance domainanalysis = instantiateAbstractArtifact(kernelI.graph, "Domain Analysis", kernelI.vertex);
ProductManagement projectmanagement ==addAbstractSubGraphArtifact(domainanalysis, "ProjectVertex : ApplicationEngineering
Instance Management");
Vertex : Instance productmanagement addAbstractSubGraphArtifact(domainanalysis,"Product Management");
Instance productlinemanagement = addAbstractSubGraphArtifact(domainanalysis, "Product Line Management");
Instance applicationengineering = addAbstractSubGraphArtifact(domainanalysis, "Application Engineering");
Instance domainengineering = addAbstractSubGraphArtifact(domainanalysis, "Domain Engineering");
G.link(kernelI.visibility, projectmanagement, productmanagement);
G.link(kernelI.visibility, productmanagement, productlinemanagement);
G.link(kernelI.visibility, applicationengineering, productmanagement);
G.link(kernelI.visibility, applicationengineering, productlinemanagement);
G.link(kernelI.visibility, applicationengineering, domainengineering);
G.link(kernelI.visibility, domainengineering, productlinemanagement);
G.link(kernelI.visibility, domainengineering, productmanagement);
Vertex : ProductLineManagement Vertex : DomainEngineering

16. Vertex : DomainAnalysis.ProductLineManagement
Vertex : Organization
Vertex : System
Vertex : ManagedFeature

17. Vertex : DomainAnalysis.ProductLineManagement
Vertex : Organization
Model expressed through the Gmodel API
Vertex : System
Instance organization = addAbstractSubGraphArtifact(productlinemanagement, "Organization");
Instance system = addAbstractSubGraphArtifact(productlinemanagement,"System");
Instance managedfeature = addAbstractSubGraphArtifact(productlinemanagement, "Managed Feature");
G.link(kernelI.visibility, organization, system);
G.link(kernelI.visibility, system, managedfeature);
Vertex : ManagedFeature

18. Vertex : DomainAnalysis.ProductManagement
Vertex : Product
Vertex : ProductFeedback Vertex : UseCase
Vertex : ...ProductLineManagement.Organization Vertex : ...ProductLineManagement.ManagedFeature

19. Vertex : DomainAnalysis.ProductManagement
Vertex : Product
Model expressed through the Gmodel API
Vertex : ProductFeedback Instance product = addAbstractSubGraphArtifact(productmanagement, "Product");UseCase
Vertex :
Instance productfeedback = addAbstractSubGraphArtifact(productmanagement,"Product Feedback");
Instance usecase = addAbstractSubGraphArtifact(productmanagement, "Use Case");
G.link(kernelI.visibility, product, productfeedback);
G.link(kernelI.visibility, product, usecase);
G.link(kernelI.visibility, productfeedback, organization);
G.link(kernelI.visibility, usecase, organization);
G.link(kernelI.visibility, usecase, managedfeature);
Vertex : ...ProductLineManagement.Organization Vertex : ...ProductLineManagement.ManagedFeature

20. Vertex : DomainAnalysis.ProjectManagement
Vertex : Timebox
Vertex : ...ProductManagement.Product

21. Vertex : DomainAnalysis.ProjectManagement
Vertex : Timebox
Model expressed through the Gmodel API
Vertex : ...ProductManagement.Product
Instance timebox = addAbstractSubGraphArtifact(projectmanagement, "Timebox");
G.link(kernelI.visibility, timebox, product);

22. Vertex : DomainAnalysis.DomainEngineering
Vertex : Development
Vertex : Design
Vertex : DomainAnalysis.ProductLineManagement Vertex : ...ProductManagement.UseCase

23. Vertex : DomainAnalysis.DomainEngineering
Vertex : Development
Model expressed through the Gmodel API
Vertex : Design
Instance development = addAbstractSubGraphArtifact(domainengineering, "Development");
Instance design = addAbstractSubGraphArtifact(domainengineering, "Design");
G.link(kernelI.visibility, development, design);
G.link(kernelI.visibility, design, productlinemanagement);
G.link(kernelI.visibility, design, usecase);
Vertex : DomainAnalysis.ProductLineManagement Vertex : ...ProductManagement.UseCase

24. Vertex : DomainAnalysis.ApplicationEngineering
Vertex : Design Vertex : Development
Vertex : ...DomainEngineering.Design Vertex : ...DomainEngineering.Development
Vertex : ...ProductLineManagement.Organization
Vertex : ...ProductManagement.UseCase Vertex : ...ProductLineManagement.ManagedFeature

25. Vertex : DomainAnalysis.ApplicationEngineering
Vertex : Design Vertex : Development
Model expressed through the Gmodel API
Vertex : ...DomainEngineering.Design appdevelopment = addAbstractSubGraphArtifact(applicationengineering, "App Development");
Instance Vertex : ...DomainEngineering.Development
Instance appdesign = addAbstractSubGraphArtifact(applicationengineering, "App Design");
G.link(kernelI.visibility, appdevelopment, appdesign);
G.link(kernelI.visibility, appdevelopment, development);
G.link(kernelI.visibility, appdesign, design);
G.link(kernelI.visibility, appdesign, usecase);
G.link(kernelI.visibility, appdesign, organization);
G.link(kernelI.visibility, appdesign, managedfeature);
Vertex : ...ProductLineManagement.Organization
Vertex : ...ProductManagement.UseCase Vertex : ...ProductLineManagement.ManagedFeature

26. Vertex : DomainAnalysis.DomainEngineering.Design
Vertex : EntityRelationshipSchema
Vertex : HierarchicalERSchema

27. Vertex : DomainAnalysis.DomainEngineering.Design
Vertex : EntityRelationshipSchema
Vertex
Model expressed through the Gmodel API : HierarchicalERSchema
Instance entityrelationshipschema = addConcreteSubGraphArtifact(design, "Entity Relationship Schema");
Instance hierarchicalerschema = addConcreteSubGraphArtifact(design, "Hierarchical ER Schema");
G.link(kernelI.visibility, hierarchicalerschema, entityrelationshipschema);

28. Vertex : DomainAnalysis.DomainEngineering.Design.EntityRelationshipSchema
Edge : relationship
EdgeEnd : target[*]
Vertex : Entity EdgeEnd : source[*]
Vertex : Attribute
Edge : #
type
EdgeEnd : owner[1] EdgeEnd : attributes[*]

29. Vertex : DomainAnalysis.DomainEngineering.Design.EntityRelationshipSchema
Model expressed through the Gmodel API
Instance entity = addConcreteVertex(entityrelationshipschema, "Entity", kernelI.vertex);
Instance attribute = addConcreteVertex(entityrelationshipschema, "Attribute", kernelI.vertex);
Instance entity_to_attribute = G.link(kernelI.edge,
Edge : relationship
semanticIdentityFactory.createSemanticIdentity("owner", "owners"),
entity,
kernelP.minCardinality_1,
kernelP.maxCardinality_1,
kernelP.isNavigable_TRUE,
kernelP.isContainer_TRUE,
semanticIdentityFactory.createSemanticIdentity("attribute", "attributes"),
attribute,
kernelP.minCardinality_0,
kernelP.maxCardinality_n,
kernelP.isNavigable_TRUE,
kernelP.isContainer_FALSE
);
Instance entity_to_entity = G.link(kernelI.edge,
EdgeEnd : target[*] semanticIdentityFactory.createSemanticIdentity("source", "sources"),
entity,
kernelP.minCardinality_0,
kernelP.maxCardinality_n,
Vertex : Entity kernelP.isNavigable_TRUE,
EdgeEnd : source[*]
kernelP.isContainer_FALSE,
semanticIdentityFactory.createSemanticIdentity("target", "targets"),
entity,
kernelP.minCardinality_0, Vertex : Attribute
Edge : #
kernelP.maxCardinality_n,
kernelP.isNavigable_TRUE, pluralName = Attributes
EdgeEnd : owner[1]
kernelP.isContainer_FALSEEdgeEnd : attributes[*] String : type
);

30. EntityRelationshipSchema : ApplicationEngineering.Design.CustomerRelationshipManagement
Entity : Order
databaseLocation
relationship : #
target : orders[*]
Entity : Product source : products[*]
Boolean : isIncorrect
Attribute : price
#:#
type = amtOfMoney
owner : owner[1] attribute : prices[*] amtOfMoney.usd
amtOfMoney.from
amtOfMoney.until

31. EntityRelationshipSchema : ApplicationEngineering.Design.CustomerRelationshipManagement
Model expressed through the Gmodel API
Instance crm = instantiateConcreteArtifact(design, "CRM", entityrelationshipschema);
Instance crm_product = addConcreteVertex(crm, "Product", entity); Entity : Order
Instance order = addConcreteVertex(crm, "Order", entity);
pluralName = Orders
relationship : #
Instance product_to_order = G.link(entity_to_entity, String : databaseLocation
semanticIdentityFactory.createSemanticIdentity("product", "products"),
target : orders[*]
order,
kernelP.minCardinality_0,
kernelP.maxCardinality_n,
kernelP.isNavigable_TRUE,
kernelP.isContainer_FALSE,
semanticIdentityFactory.createSemanticIdentity("order", "orders"),
crm_product,
kernelP.minCardinality_0,
kernelP.maxCardinality_n,
kernelP.isNavigable_TRUE,
kernelP.isContainer_FALSE
);
Instance product_to_price = G.link(entity_to_attribute,
semanticIdentityFactory.createSemanticIdentity("owner", "owners"),
order,
kernelP.minCardinality_1,
Entity : Product source : products[*]
kernelP.maxCardinality_1,
kernelP.isNavigable_TRUE,
Boolean : isIncorrect
pluralName = Products kernelP.isContainer_TRUE,
semanticIdentityFactory.createSemanticIdentity("price", "prices"),
crm_product, Attribute : price
#:#
kernelP.minCardinality_0,
kernelP.maxCardinality_n, pluralName = prices
kernelP.isNavigable_TRUE,
owner : owner[1] attribute : prices[*] type = amtOfMoney
kernelP.isContainer_FALSE
BigDecimal : amtOfMoney.usd
);
BigDecimal : amtOfMoney.from
BigDecimal : amtOfMoney.until

32. CustomerRelationshipManagement : InstalledApplication.Sofismo
Entity Order : #
databaseLocation = Lenzburg
relationship : # : #
target : orders : #[#]
Entity : Product : # source : products : #[#]
isIncorrect = true
Attribute : price : #
#:#:#
amtOfMoney.usd = 3.5
owner : owner : #[#] attribute : prices : #[#] amtOfMoney.from = 2009 04 12
amtOfMoney.until = 2009 12 31

33. Language Extension Example

34. Vertex : DomainAnalysis.DomainEngineering.Design.HierarchicalERSchema
Edge : relationship
EdgeEnd : target[*]
EdgeEnd : source[*]
Vertex : Entity
Edge : relationship
EdgeEnd : target[0] EdgeEnd : target[1] EdgeEnd : source[*]
isNavigable = false
Edge : relationship
EdgeEnd : source[0]
isNavigable = false
Vertex : RootEntity Vertex : ChildEntity