Docstoc

Introduction to Software Reuse

Document Sample
Introduction to Software Reuse Powered By Docstoc
					MOF Meta-Models and UML Profiles

            Jacques Robin




                      Ontologies
                      Reasoning
                      Components
                      Agents
                      Simulations
                           Outline

   MDA’s modeling level hierarchy
   Purposes of meta-models in MDA
   Meta-Object Facility (MOF): a standard language for meta-modeling
   Modeling with software abstractions beyond UML
   UML Profiles
     Multi-Agent Simulations
     Others
      MDA’s Modeling Level Hierarchy


                                                   MOF
Level M3     Meta-
                                                  + OCL
           Meta-Model



                                                    MOF
Level M2   Meta-Model                             + OCL




                            UML   AND    UML        AND    Special Purpose
Level M1      Model       + OCL   -OR   Profile     -OR   Modeling Language



             Running                      Implementation
Level M0    Application                 Running on Platform
     Purposes of Meta-Models in MDA

 Define modeling languages
    Their abstract syntax
    Their formal semantics
 Define source and target anchors for model transformations
 What about APIs and Libraries?
    They are all written in a given language
    They are thus best viewed as built-in model elements to reuse than as
    part of a modeling language
    Thus they should be part of platform models, not of language meta-
    models
             What is Meta-Modeling?

 Meta-Modeling vs. Modeling
    Similar formalisms but different purposes
    One models applications and meta-models languages and formalisms
 Meta-Modeling vs. Ontology Engineering
    An ontology is a domain knowledge model, not a meta-model
    But a domain is an intermediate level of abstraction and generality
    between application and language
 Meta-Modeling Methodologies
    Uncharted territory
    Should integrate and reuse principles and techniques from:
       Application modeling (formalism similarities)
       Language design (purpose similarities)
       Ontology engineering (process similarities)
   OMG’s Meta-Object Facility (MOF)

 Key idea:
    Instead of defining entirely new languages for the M2 and M3 levels
    Reuse structural core of mature, well-known, well-tooled M1 level
    language (UML Infra-Structure)
 Advantages of MOF over traditional formalisms such as grammars to
  define languages:
    Abstract instead of concrete syntax (more synthetic)
    Visual notation instead of textual notation (clarity)
    Graph-based instead of tree-based (abstracts from any reader order)
    Entities (classes) can have behavior (grammar symbols do not)
    Relations between elements include generalization and undirected
    associations instead of only composition and order
    Specification reuse through inheritance
 Additional advantages with OCL:
    Allows expressing arbitrary complex constraints among language
    elements (more expressive)
    Allows defining formal semantics without mathematical syntax
                       UML2 Infra-Structure



      MOF
   Meta-Model
Package Structure



                MOF2
    Essential MOF (EMOF) Meta-Model

 Minimum bootstrap elements for
  modeling, meta-modeling and MDA tools
 Includes only classes, attributes,
  operations, packages and primitive types
  from UML2 Infra-Structure
 Does not includes associations, which are
  replaces by references (properties whose
  values are classes instead of primitive
  types)
 Basis for Ecore the metametamodel
  implemented by the Eclipse Modeling
  Framework
 Any CMOF meta-model can be
  transformed into an EMOF meta-model
 EMOF extends UML2 Infra-Structure
  with elements to represent:
     Instances unique identifiers
     Their reflective relations with classes
     Minimal tag-value based extension
      mechanism
EMOF: Basic Package
EMOF: Basic Package
EMOF: Reflection and Common Packages
 Views any model element as an instance of a meta-model meta-class
 Provide operations that cut across MDA layers to manipulate model and
  meta-model elements as meta-objects of their meta-classes
 Provides meta-meta-model of a generic reflective API to programmatically
  manipulate models
 EMOF Meta-Model: Identifier Package
 OID: class property with feature isID true or URI
 Extent: OID value range
 useContainment(): when true, all contained elements
  are added to containing element’s extents
  (recursive containment)
 e.g., if object o1 has property p1 which contains
  objects o2, which in turns has property p2 which
  contains object o3, when useContainment() is true
  then the extent for o1 includes {o1, o2, o3}
 Elements(): returns extent members
 URIExtent: extent where OIDs are URIs
  instead of properties
 A URI (Universal Resource Identifier) is either,
 A URL (Universal Resource Locator) providing a name for a
   resource accessible on a network and a mean to retrieve it; or
 A URN (Universal Resource Name) providing a name for a resource in a namespace.

                                    URI syntax and examples
        scheme   authority            path                         query          fragment
        foo;     ///example.com:8042 /over/there                   ?name=ferret   #nose
        urn:                          example:animal:ferret:nose
            EMOF: Extension Package


 Any element can be tagged to extend modeling language vocabulary
CMOF: Construct Package
CMOF: Reflection




                   To identify operation
                   parameters by names
                   instead of merely by
                         position
          Is UML2 Enough? Too Much?

 UML2 covers domain and platform independent modeling concepts for the
  object-oriented, relational, imperative, concurrent, event-based,
  distributed and constraint (through OCL) computational paradigms
 It does not cover:
     Object-oriented reflection
     Functional paradigm which includes powerful generative meta-programming and
      type inference
     Rule-based paradigm which includes powerful model transformation mechanisms
      and general logical inference
     Domain-specific modeling concepts
     Platform-specific abstractions
 So it is not enough for key applications and domains
 UML2 thus needs an extension mechanism
 But isn’t UML2 rather already too much?
 Yes, it is only a vast menu of concepts only a few of which are practically
  useful for a particular application or application domain
 To be highly reusable it is also necessarily very under-constrained
 So UML2 also needs a reduction mechanism allowing a methodology to
  choose a relevant subset of its metamodel and add more stringent OCL
  constraints among the elements of such subset
        Tailored Modeling with
   Software Abstractions Beyond UML
 Software abstractions beyond UML can be classified as:
    Specializing UML abstractions (i.e., UML2 meta-model elements)
    Generalizing UML abstractions
    Being unrelated to UML abstractions
 Approaches:
1. No MOF, no UML (the Microsoft way)
    Create and use domain-specific or even application-specific meta-modeling,
     modeling and model transformation languages
2. Pure MOF, no UML:
    Create domain-specific or application-specific modeling language that does not
     reuse any UML meta-model element but which is specified as a MOF meta-model
3. MOF meta-model reuse operators applied to UML packages:
    Define MOF meta-model of new modeling language that reuses UML meta-model
     elements and add new ones
4. UML Profile approach (the IBM way)
       Define specializations of UML abstractions by stereotyping UML meta-model
       elements
  Tailored Modeling: Domain-Specific
 Meta-Modeling and Modeling Approach
 Advantage:
   No need to understand complex, large and at times under-examplified
    MOF2 and UML2 specifications
 Drawbacks:
    For each new domain or application
       Need to redefine entire MDA language infra-structure alternative to OMG´s
       Need to implement CASE tools for non-standard languages




                                        D1, D2
                     GUI Editor for
                                      Meta-Models
                     D2 Diagrams
                                         in D2




                     GUI Editor for     Model in     D1 Model
                     D1 Diagrams      Language D1   Repository
Tailored Modeling: Pure MOF Approach

 Pure MOF approach
 Does not use UML                            UML          D Meta-Model
 Advantages:                                Editor           in MOF

    No need to artificially relate new
    abstractions to UML abstractions
 Drawbacks:                              GUI Editor for
                                                             Model in
                                                             Dedicated               EMF
    Need to define entirely new meta-     D Diagrams
                                                            Language D
     model that does not reuse any
     elements consolidated by OMG’s                                          generates
     long meta-modeling experience
    Need to develop entirely new
                                                           Menu Editor for
     graphical notation and editors                         D Diagrams
    Need to develop all model
     manipulation services
     (code generation, test generation,
     reverse engineering) that UML
     CASE tools already provide
        Tailored Modeling:
Meta-Model and MOF Reuse Operators
 Advantages:
    Reuses consolidated elements
    from UML2 meta-model                                   UML2
                                                         Meta-Model
 Drawbacks:                                              in MOF

    Need to extend UML’s                                       << reuse >>

    graphical editors to draw
    elements in D\UML2                     UML          D Meta-Model
                                          Editor           in MOF
    Need to extend model
    manipulation services
    (code generation, test
    generation, reverse engineering)   GUI Editor for
                                                          Model in
                                                          Dedicated               EMF
    of UML CASE to modeling             D Diagrams
                                                         Language D
    elements in D\UML2                                                    generates

    Current MOF operators do not                       Menu Editor for
    cover UML2 concept                                   D Diagrams
    generalizing reuse, only reuse
    “as is” or as specialization
                                 Tailored Modeling:
                                UML Profile Approach
     UML2 meta-classes sub-categorized by stereotypes
     Advantages:
           Maximum reuse the entire OMG language infra-structure
           Maximum reuse of UML CASE tools (no need to develop any new tool)
     Drawbacks:
           Risk to “artificially” recast modeling abstraction as specializations of UML ones
           Little to reuse for non-object oriented modeling languages



                                                      Promotes property value to
                                                         the metaclass level
                                                                                                                 UML2
                                                                                                      UML
                                                                                                               Meta-Model          EMF
        Package                 Class                                                                Editor
                                                                                                                in MOF
                                          metaclass

                                                                                   *
                         *                 *
         Profile             Stereotype           ExtensionEnd                         Extension
                                           type                    ownedEnd                                                      Model in
          *
                             icon                                                                             P UML2 Profile    Dedicated
*                                                                                                                              UML2 Profile P
    ProfileApplication          Image                 Property                         Association
                                             UML2 Profiles
         Package                 Class
                                           metaclass

                                                                                  *
                          *                 *
          Profile             Stereotype            ExtensionEnd                      Extension
                                            type                    ownedEnd                              <<agent>>                   <<agent>>
           *
                              icon                                                                           ag1                         ag2
*                                                                                                                       <<proxy>>
    ProfileApplication           Image                 Property                       Association


// Creating agent stereotype                       // Stereotyping a2 as agent
a = Factory.create(metaclass:Stereotype)           a2e = Factory.create(metaclass:Extension)               Component        Associaton
a.set(property:name, value:”<<agent>>”)            a2.set(property:Extension, value:a2e)
                                                   a2ee = Factory.create(metaclass:ExensionEnd)
                                                   a2e.set(property:ownedEnd, value:a2ee)
// Creating Components a1 and a2
                                                   a2ee.set(property:type, value:a)
a1 = Factory.create(metaclass:Component)                                                                      Agent           Proxy
a1.set(property:name, value:”ag1”)                 // Create proxy stereotype
a2 = Factory.create(metaclass:Component)           p = Factory.create(metaclass:Stereotype)         // Stereotyping a12 as proxy
a2.set(property:name, value:”ag2”)                 p.set(property:name, value:”<<proxy>>”)          a12e = Factory.create(metaclass:Extension)
                                                                                                    a12.set(property:Extension, value:a12e)
// Stereotyping a1 as agent                        // Creating Association between a1 and a2        a12ee = Factory.create(metaclass:ExensionEnd)
a1e = Factory.create(metaclass:Extension)          a12 = Factory.create(metaclass:Association)      a12e.set(property:ownedEnd, value:a12ee)
a1.set(property:Extension, value:a1e)              a12e1 = Factory.create(metaclass:Property)       a12ee.set(property:type, value:p)
a1ee = Factory.create(metaclass:ExensionEnd)       a12e2 = Factory.create(metaclass:Property)
a1e.set(property:ownedEnd, value:a1ee)             a1.set(property:ownedAttributes, value:a12e1)
a2ee.set(property:type, value:a)                   a2.set(property:ownedAttributes, value:a12e2)
                                                   a12.set(property:memberEnd, value:a12e1)
                                                   a12.set(property:memberEnd, value:a12e1)
                                             UML2 Profiles
// Creating S1 and S2 stereotypes
s1 = Factory.create(metaclass:Stereotype)
s1.set(property:name, value:”<<S1>>”)                        Package                  Class
                                                                                                 metaclass
s1 = Factory.create(metaclass:Stereotype)
s1.set(property:name, value:”<<S2>>”)                                                                                                     *
                                                                              *                    *
// Creating classes C1 and C2                                 Profile               Stereotype              ExtensionEnd                      Extension
c1 = Factory.create(metaclass:Class)                                                              type                     ownedEnd
                                                               *
c1.set(property:name, value:”C1”)                                                  icon
                                                     *
c2 = Factory.create(metaclass:Class)                                                  Image                   Property                        Association
                                                         ProfileApplication
c2.set(property:name, value:”C2”)
// Creating instanceSpecification i1 of C1
i1 = Factory.create(metaclass:InstanceSpecification)
                                                                                                               neither direct
i1.set(property:name, value:”i1”)                                                                      C1      nor inherited     C2
                                                                                      S1 only a                                           S2 only a
i1.set(property:classifier, value:c1)                                             stereotype of C1              association           stereotype of C2
// Stereotyping i1 as <<S1>>                                                          but not a                   between                 but not a
c1e = Factory.create(metaclass:Extension)                                          sub-metaclass                 C1 and C2             sub-metaclass
c1.set(property:Extension, value:c1e)                                                   of C1          S1          X             S2         of C2
c1ee = Factory.create(metaclass:ExensionEnd)                                                                    No allowed
c1e.set(property:ownedEnd, value:c1ee)                                                     i1: <<S1>> C1        association     i2: <<S2>> C2
c1ee.set(property:type, value:s1)                                                                                 between
                                                                                         instance i1                                instance i2
                                                                                                                 S1 and S2
// Stereotyping i2 as <<S2>>                                                           cannot be of S1                            cannot be of S2
c2e = Factory.create(metaclass:Extension)                                                only of C11                                 only of C2
                                                                                         w/ property                                w/ property
                                                                                                                   X
c2.set(property:Extension, value:c2e)
                                                                                       stereotype = S1                            stereotype = S2
c2ee = Factory.create(metaclass:ExensionEnd)
c2e.set(property:ownedEnd, value:c2ee)                                                    i1 and i2 cannot be linked for lack of an association
c2ee.set(property:type, value:s2)                                                             between their respective classes C1 and C2
                                                                                               but reuse of concrete syntax of C1 and C2
       UML2 Extension via Sub-Metaclasses

// Creating classes C1, C2, S1, S2                                                                                             superclass
                                                // Creating instanceSpecification i1 of S1
c1 = Factory.create(metaclass:Class)            i1 = Factory.create(metaclass:InstanceSpecification)
                                                                                                                               *
c1.set(property:name, value:”C1”)               i1.set(property:name, value:”i1”)                                                   Class
c2 = Factory.create(metaclass:Class)            i1.set(property:classifier, value:s1)
c2.set(property:name, value:”C2”)
s1 = Factory.create(metaclass:Class)                                                                                                     ownedAttribute
                                                // Creating instanceSpecification i2 of S2
s1.set(property:name, value:”S1”)
                                                i2 = Factory.create(metaclass:InstanceSpecification)                               Property
s2 = Factory.create(metaclass:Class)
s2.set(property:name, value:”S2”)               i2.set(property:name, value:”i2”)
                                                                                                                                         menberEnd
                                                i2.set(property:classifier, value:s2)
// Specializing C1 by S1 and C2 by S2                                                                                          Association
s1.set(property:superclass, value:c1)           // Creating instanceSpecification of S12
s2.set(property:superclass, value:c2)           is12= Factory.create(metaclass:InstanceSpecification)
                                                is12.set(property:classifier, value:s12)                      neither direct
// Creating Association between S1 and S2                                                                     nor inherited
s12 = Factory.create(metaclass:Association)                                                                    association
                                                                                                        C1       between            C2
s12e1 = Factory.create(metaclass:Property)
                                                                                                                C1 and C2
s12e2 = Factory.create(metaclass:Property)
s1.set(property:ownedAttributes, value:s12e1)                                             S1 a                                                  S2 a
s2.set(property:ownedAttributes, value:s12e2)                                                                    S12
                                                                                      sub-metaclass S1                              S2      sub-metaclass
s12.set(property:memberEnd, value:s12e1)                                                  of C1                  Allowed                        of C2
s12.set(property:memberEnd, value:s12e1)                                                                       association
                                                                                                   i1: S1        between             i1: S1
s12.set(property:name, value:”S12”)
                                                                                                                S1 and S2

                                                                                             i1 and i2 can be linked by an instance of S12
                                                                                             but no reuse of concrete syntax of C1 and C2
      UML2 Extension via Sub-MetaClasses
               and Stereotype
          Package                  Class                                                              superclass
                                              metaclass

                                                                                    *                 *
                            *                    *                                                         Class
           Profile              Stereotype                ExtensionEnd                  Extension
                                                 type                    ownedEnd
            *
                                icon                                                                          ownedAttribute
 *
      ProfileApplication           Image                    Property                    Association       Property

                                                                                                              menberEnd

                                                                                                      Association
                                neither direct
                                nor inherited
                                 association
   S1 both a           C1          between           C2          S1 both a
 sub-metaclass                    C1 and C2                    sub-metaclass
and a stereotype                                              and a stereotype
     of C1                         aS1S2                           of C1
                       S1                            S2
                                  Allowed
                                association
           i1: <<Si1>> S1         between            i2: <<Si2>> S2
                                 S1 and S2

                i1 and i2 can be linked by an instance aS1S2
                 and reuse of concrete syntax of C1 and C2
     A UML2 Profile Definition Process

1. Create a special purpose meta-model of an application domain,
   language or platform
2. Identify the top-level meta-classes s1, ..., sn of this meta-model (i.e.,
   those with no generalizations)
3. Identify in the UML2 meta-model, the concrete meta-classes
   g1, ..., gn that are natural semantic generalizations of s1, ..., sn
   (respectively)
4. Extend the UML2 meta-model by defining s1, ..., sn as sub-meta-
   classes of g1, ..., gn (respectively)
5. Add OCL constraints on s1, ..., sn that specify how they specialize
   g1, ..., gn (respectively)
      MOF Meta-Model of a Simple Multi-Agent
      Simulations Modeling Language (MASML)
MAS                                                                                      ReflexAgent

                                                  2..*
ReasoningComponent                      Agent              MAS           Environment         Agent      ReasoningComponent
                          1..*
                                                                                                                                 1..*
                                                                                                                                        Sensor
                            1..*                 1..*
                   1..*                                    1..*
       Percept               Sensor        Actuator               AgentAction             ReflexAgent          ReflexComponent          Actuator
                                                                                                                                 1..*

AutomataAgent                                                                      GoalBasedAgent

                    AutomataAgent                          Agent                          GoalBasedAgent                   AutomataAgent

                                 1..*                                                                             3..*
                                                4..*
   Sensor       EnvironmentStateModel                    ReasoningComponent                    Goal                      ReasoningComponent


       PercpetInterpretationComponent                                                  EnvironmentStateModel

         ModelInitializationComponent                                                       GoalInitializationComponent


              RamificationComponent                                                           GoalUpdateComponent

   ModelBasedBehaviorStrategyComponent                                                 GoalBasedBehaviorStrategyComponent


   Actuator                                                                            ModelBasedBehaviorStrategyComponent
         MOF Meta-Model of a Simple Multi-Agent
         Simulations Modeling Language (MASML)
  KBAgent                                                                           ReflexKBAgent

                                                                1..*
 Agent      ReasoningComponent               KnowledgeBase             KBSentence     ReflexAgent            ReflexComponent



                   1..*                                                             ReflexKBAgent           ReflexKBComponent          ReflexKB
  KBAgent                  KBComponent           PersistentKB      VolatileKB
                             1..*                                         0..*
                                                                                       KBAgent                KBComponent           PersistentKB

                                                                                     context ReflexKBComponent inv Volat ileKB.isEmpty()
GoalBasedKBAgent

   GoalBasedAgent                                                                   AutomataKBAgent

                                                                                      AutomataAgent
                              6..*
  GoalBasedKBAgent                    KBComponent
                                     3 ..*          4 ..*                                                      4..*
                                                                                     AutomataKBAgent                  KBComponent
                                                                                                                            4 ..*
         KBAgent          GoalKB     EnvironmentStateModelKB
                                                                                          KBAgent             EnvironmentStateModelKB



      VolatileKB           Goal       EnvironmentStateModel                                    VolatileKB      EnvironmentStateModel
                        UML2 Profile for MAS

 MASML                   UML2               OCL Constraints:
  Meta-Model               Meta-Model         1. context Agent inv:interface
                                                 let r = required and (i = Sensor or Actuator)
                MAS                              in r.oclIsKindOf(i)
                             Component        2. context Agent inv:signal
         Environment                              let s = required.ownedReception.signal
                            isActive = true
                                                  in s.oclIsKindOf(Percept or AgentAction)
               Agent
                                              3. context Sensor inv:agent
 ReasoningComponent         Component            abstraction.oclIsKindOf(Agent)
                                              4. ...
              Sensor
                             Interface
             Actuator

              Percept
                             Signal
          AgentAction

EnvironmentStateModel

       KnowledgeBase         Model

          KBSentence
              Available UML Profiles

 By OMG:
    Enterprise Application Integration (application interoperability through
    standard metadata)
    Enterprise Distributed Object Computing (EDOC)
    QoS and Fault Tolerance
    Schedulability, Performance and Time
   Testing
 Third parties:
    Enterprise Java Beans (by Java Community Process)
    Software Services (by IBM, supported by Rational Software Architect
    UML CASE tool)
    Knowledge-Based Systems (University of York)
    Data Modeling (by agiledata.org)
    Framework Architectures (UML-F)
    Requirement Engineering with KAOS
    Formal Methods in B (UML-B)
    Embedded System Design

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:3
posted:9/1/2012
language:Unknown
pages:30