Model Driven Architecture and eXecutable UML

www.kc.com Model Driven Architecture and eXecutable UML Allan Kennedy Founder, Kennedy Carter Ltd Co-chair, OMG Object Reference Model sub-committee K E N N E D Y C A R T E R

Agenda:

MDA: Key Themes

The MDA Value Proposition

The MDA Guide and the MDA Reference Model

Supporting MDA with eXecutable UML

Model Transformation and Code Generation

Integration with the HLA/RTI

MDA: Some Key Themes

Three primary viewpoints for modelling

The Computation Independent Model (CIM)

Precise business model, oriented to stakeholders, uncommitted to specific algorithms or system boundary. Also known as a Domain Model.

The Platform Independent Model (PIM)

Precise, computationally complete (executable), uncommitted to any specific platform (portable), oriented to stakeholders (prototyping) and developers (a testable specification), a long life asset

The Platform Specific Model (PSM)

Precise, complete, conforms to constraints of a specific (class of) platform(s), probably generated from a PIM, oriented to technology experts

Interoperability defined at the model level, not the middleware level

Models are integrated in order to construct complete systems

Models are derived from other models by (partially) automated transformation

So, MDA promises to be rigorous but lightweight, -> agile modelling

MDA Models are Strategic Long-Life Assets

“ A 20 year, standards-based software architecture”

Wouldn’t it be nice to know that your strategic assets are correct ?

They need to be tested

They need to be executable

UML becomes executable when used with an action language

xUML models are finished when they execute their acceptance test correctly

xUML models are validated specifications which offer a strong contractual basis for implementation by external contractors or in-house teams

MDA Models: Integration and Interoperability

“ Integrate what you have built with what you will build”

Models of legacy assets, COTS products and new developments

… are integrated to create platform independent models of entire systems or services.

Models can exist as legacy code or a set of executable interface definitions - UML is not the only suitable formalism

Interoperability is defined at the model level not the middleware level

MDA Models Are Future Proof

“ Tracking the next best thing”

Platform Independence makes models future proof, capable of being ported to faster, better, cheaper platforms as they become available

Standardised mappings for common platforms are built into MDA tools

Specialised mappings to target any platform are specified with configurable model transformation tools.

Automated mappings can guarantee interoperability between systems deployed on different platforms

Automated mappings simplify the creation of a safety argument

eXecutable UML – A precise modelling formalism:

Subset of UML

Action Semantics compliant Action Language - ASL (UML 1.5)

# navigate from this account instance to the owning customer instance owningCustomer = this -> R1 # unlink this instance from the owning customer via R1 unlink this R1 owningCustomer # find the set of all other account instances owned by that customer {otherOwnedAccounts} = owningCustomer -> R1 # if there are no other owned accounts for this customer, then # send a deletion event to the customer instance if countof {otherOwnedAccounts} = 0 then generate deleteCustomer() to owningCustomer endif # delete this instance of account delete this … .the result is a fully executable model

eXecutable UML – A proven development process oriented towards...

Executable modelling

Large-scale reuse

Pattern based design

SPECIFY DOMAINS Identify new/reused domains Model system use cases VALIDATE PIMs Execute domain use cases Execute system use cases BUILD PLATFORM INDEPENDENT DOMAIN MODELS Model Domain Use Cases Build Static Model Build Dynamic Models Specify Actions Execute and debug xUML models FORMALISE ABSTRACT PLATFORM SPECIFIC MODEL Select or develop suitable patterns and mechanisms (Build/Buy xUML compiler) PRODUCE TARGET CODE Apply design patterns to xUML models (manually or automatically) Perform target testing

MDA with xUML: Domain Model

Domain Model

(Package Diagram):

The software application space

is partitioned into multiple

platform independent domain

models

Mappings between the

domains are defined as contracts

for required and provided

services

MDA with xUML: Class Diagrams

Class Diagrams:

Within each platform

independent domain model,

conceptual entities

are modeled first:

classes,attributes, and

associations are abstracted

Behavior, though considered, is

not modeled explicitly in this

view

MDA with xUML: State Charts

State Charts:

Behavior is formalized during

state modeling

Class lifecycles are modeled

using signal-driven state

machines

Class operations are defined

MDA with xUML: Action Language

Action Specification Language:

State actions and class

operations are specified using

the Action Specification

Language (ASL)

ASL is a higher order and much

simpler language than a typical

high order language (e.g. C++)

ASL deals with UML concepts,

not implementation concepts

ASL was a major influence on

the newly adopted Precise

Action Semantics for the UML

MDA with xUML: Testing and Debugging PIM’s

The iUML Simulator provides a model execution environment

Single stepping, breakpoints, browsing of run time objects

Can integrate with legacy code

Batch (regression) testing of models

MDA with xUML: Integrating Models Air Traffic Control System Build Set counterpartIcon = this -> CPR1 $USE UI [ ] = makeIconFlash[ ] on counterpartIcon $ENDUSE CPR1 Bridge operation counterpart association Air Traffic Control Domain <<required interface>> Air Traffic Controller Aircraft requestPermission ToTaxi required operation User Interface Domain Icon <<provided interface>> Client makeIcon Flash provided operation

MDA with xUML: PIM to PSM Mappings

xUML Process supports fully automatic transformation to PSMs

Mapping rules can be specified …

(part of) xUML Class Attribute Signal Design Metamodel Implementation Metamodel Define Mapping xUML Metamodel Define Mapping (part of) Design Metamodel (object-based) Class PrivateDatum PublicMethod (part of) Ada 83 Metamodel Package BodyVariable SpecSubprogram

MDA with xUML: Mark-ups

Design Tags

Class Allocation

Program Allocation

Max Instance Count

Event Rate

Event Queue

Throw Away

Initialization

Source Type

Subtype of

etc.

Automatic Code Generator Application Software Interface Definition Software Execution Platform Specific Language Specific Defines © 2001 Lockheed Martin Corporation Source Code Files ... ... ... ... xUML Models ... ...

The iCCG Framework

Configurable Code Generator:

Code Generator is developed

using the same eXecutable

MDA strategy

Kennedy Carter supplies a

set of xUML models (known

as the Configurable Code

Generator) that serve as a

generic translation framework

MDA with xUML: Systematic Mappings

Systematic Mappings can always be expressed by Action Language operating on the (meta) model of xUML….

is provided by 0..* has 0..* R2 Class name keyLetter Operation Name type class Class<ClassName> { public: <returnType1> <operationName1>(); <returnType2> <operationName2>(); //………. private: static char *className; static char *classKeyLetter; //……. <attribute1Type> <attributeName1>; <attribute2Type> <attributeName2>; <attribute3Type> <attributeName3>; <attribute4Type> <attributeName4>; //……. }; C ++ Code Pattern {allClasses} = find-all Class for eachClass in {allClasses} do $FORMAT code_file class Class[T:eachClass.name] { public: $ENDFORMAT {theOperations} = eachClass -> R2 for eachOperation in {theOperations} do $FORMAT code_file [T:eachOperation.type] [T:eachOperation.name](); $ENDFORMAT endfor $FORMAT code_file private: static char *[T:eachClass.name]; static char *[T:eachClass.keyLetter]; $ENDFORMAT endfor Mapping Rules in ASL

Extending iCCG with a Platform Model

Code Generator Development:

The Configurable Code

Generator (iCCG) may be

adapted to the meet the

requirements of any Platform

Specific Implementation (i.e.

of any Application Software

Interface)

Code Generator and

Application Software develop-

ment may be performed

concurrently with the same

methods and tools

Configurable Code Generation -Summary Can support very sophisticated mappings iCCG Code Generator Class name keyLetter Operation Name type R2 iCCG Provided Metam odels Wheel number current speed Valve number state R17 Project domain models Project’s code {allClasses} = find-all Class for eachClass in {allClasses} do $FORMAT code_file class Class[T:eachClass.name] { public: $ENDFORMAT {theOperations} = eachClass -> R2 for eachOperation in {theOperations} do $FORMAT code_file [T:eachOperation.type] [T:eachOperation.name](); $ENDFORMAT endfor $FORMAT code_file private: static char *[T:eachClass.name]; static char *[T:eachClass.keyLetter]; $ENDFORMAT endfor Project written mappings in ASL Project Code Generator Generate an executable using an existing code generator

Supporting MDA with eXecutable UML iUML Product Suite