32441_10061845_S-OBJECT ORIENTED ANALYSIS AND DESIGN

8/7/2019 32441_10061845_S-OBJECT ORIENTED ANALYSIS AND DESIGN

1/115

Model Driven Development

With Borland Together ControlCenter

Tom Gullion

Product Manager, Together Products

Borland Software Corporation


2/115

Agenda


3/115

1. Introduction


4/115

Tutorial Description

In this tutorial, we discuss the background

concepts behind model-driven

development and how it relates toindustry trends like MDA. We concentrate

on showing what you can do today and

present a vision for what you'll be able to

do in the future.Prerequisites: Some experience with UML,

OOAD, and Java.


5/115

Tutorial Goals

Define and describe model-driven

development (MDD)

Describe model-driven architecture (MDA)

We all leave with a somewhat clear pictureof present and future functionality


6/115

Model-Driven Development Defined

Models are the focus of development

not an intermediate work product

Model and Code are of equal importance LiveSourceTM is key

Model and code are always in sync

The code is the model, the model is the code


7/115

LiveSourceTM is key

Model and code are always in sync


8/115

Ban on intermediate work products!

Models are the focus of development, not an

intermediate work product

No more stale design documents

No more out-of-date requirements documents

Leverage integrations to always work with live

project artifacts!


9/115

MDD/MDA Terms

Model

Platform

CIM

PIM

PSM

Transformations


10/115

Model

Merriam-Webster Online:

structural design

a system of postulates, data, andinferences presented as a mathematicaldescription of an entity or state of affairs

Joaquin Miller: Specification of a system and its

environment


11/115

Model Taxonomy


12/115

Platform

general definition

middleware platforms J2EE

.NET

OS platforms Linux

Mac OSX

can be more specific BEA WebLogic Platform 8.1

OMG definition

general approach


13/115

OMG definition of platform

MDA recognizes that the target "platform" will likely be a

collection of platforms: Linux+JBoss+J2EE+Hibernate+

MySQL+Struts+JSP


14/115


15/115

CIM in Together

Separate project vs separate package

Separate project provides good isolation

Can be a challenge for traceability

Separate package partitions ok

Much better for managing tracability

Configure diagrams to Analysis Detail- [see ControlCenter]


16/115

High-level of abstraction

Reduce complexity

Model the what not the how

Visualize collaborations

Form over function


17/115

Color modeling

Peter Coads advice:

Assign colors to categories of classes [diagramelements]

Spatial Layering

How many colors

Five is too many - Hideaki Chijiiwa (Color Harmony)

Which colors Leonardo Da Vinci

red, yellow, green, blue

Soften to pastels so text is easy to read Pink, pastel yellow, pastel green, pastel blue

3M was there before us Four color Post-itTM Notes


18/115

analysis model


19/115

PIM

Platform Independent Model

Collection of UML diagrams

Use case, activity, class, state, etc. Always important to define platform for

your context

Independence is relative

Must specify the platform from which this

model is independent


20/115

PIM

PIM in Together

design model

design model with OCL color modeling here too


21/115

design model


22/115

design model with OCL


23/115

color modeling here too


24/115

PSM

Platform Specific Model

Generally specific to

Some technology; A programming language;

Middleware

Execution environment

Typically class diagrams


25/115

PSM in Together

Togethers historic "sweet spot"

can be reverse-engineered too


26/115

Transformations

CIM->PIM Biz process model to UML model

PIM->PSM

the classic design to impl transformation Single class to multiple transformation

PIM->PIM Analysis to Design transformation

Object model to ER Logical transformationPSM->Code MDA term for LiveSource Model compiler


27/115

Transformations (continued)

Model->Model

Activity diagram to Ant script tranformation

Interaction diagram to test scripts

Tool Support Built-in LiveSource Approach

Deployment Support

Executable Model Support

Pluggable Provide an API for transformation plug-ins

Customizable Provide an API for transformation plug-ins


28/115

PIM->PIM

Analysis to Design transformation

Object model to ER Logical transformation


29/115

PIM->PSM

the classic design to impl transformation

Single class to multiple classes

transformation


30/115

PIM->PSM

analysis class to EJB collection (EJB +

remote + home interface classes)


31/115

PSM->Code

MDA term for LiveSource

Together does this todayautomatically!

Model compiler


32/115

Model->Model

Activity diagram to Ant script transformation

Interaction diagram to test scripts


33/115


34/115

2. Practices of MDD


35/115

Iterative Devel Defined

"Development is organized into a series of

short, fixed-length mini-projects called

iterations; the outcome of each is atested, integrated, and executable

system.

Craig Larman. Applying UML and Patterns,Second Edition. Prentice-Hall PTR, 2002


36/115

Iterative, incremental

From Walker Royce,From Walker Royce,http://www.sei.cmu.edu/cbs/spiral2000/february2000/Roychttp://www.sei.cmu.edu/cbs/spiral2000/february2000/Royc

e/e/


37/115

Benefits

mitigate risks early, rather than late

visible progress

early feedback

manage complexity by breaking up work into

manageable chunks

learning within an iteration can be methodically

used to improve subsequent iterations

Craig Larman, Applying UML and Patterns, Second Edition.

Prentice-Hall PTR, 2002


38/115

FDD

Note: two-week timeboxing


39/115

Iterative Modeling Guidelines

Dont have to do it all right now

Freedom to Delete

Avoid intermediate work products

Automate documentation generation


40/115


41/115

Modeling Requirements

Plain Text Requirements

Verify Requirements with an Object Model

Visualize RequirementsModel the User Interface


42/115

Plain Text Requirements

The customers credit cardis scanned. The systemcreates a transaction andthe financial institutionverifies the credit card. Ifthe credit is declined, anerror logged.

The transaction is finalizedand a receipt is printed.Finally, the customer

receives their goods.

Note the miracle and black hole

activities discovered when the narrative

was visually modeled.


43/115

Verify Requirements with an

Object ModelStreamlined Object Modeling suggests:"clients are intimately familiar with details but are stuck in how it is

done now, overlooking potential improvements"

talking about users and user scenarios is bad because it "tends to

bring focus on how the old system worked, not what the realunderlying business process should be."

"Object modeling succeeds because it focuses on the domainobjects and forces everyone in the group to take the object'sviewpoint. Putting people in the same viewpoint is a powerfultechnique for gaining group consensus. By contrast, buildingscenarios around users compels every participant to considerthe system from his own personal viewpoint, and how he

wants it to work."

"Once the object model is created, then user scenarios are helpfulin fleshing out the "how".'


44/115


45/115

Visualizing Requirements 2


46/115



47/115



48/115

User Interface Models

from

Lean Interaction Design

and Implementation:Using Statecharts with

Feature Driven Development

By David J. Anderson andBran OByrne


49/115

2. Practices of MDD


50/115

Modeling Conventions

See Scott Amblers BorCon 2004 session!

read his book or web site:www.agilemodeling.com/style

Examples:

Visual layout suggests order

Naming conventions

Size matters

Color modeling Model structure Traceability
http://www.agilemodeling.com/stylehttp://www.agilemodeling.com/style


51/115


52/115


53/115


54/115

Color modeling


55/115

Model structure


56/115


57/115

2. Practices of MDD


58/115


59/115


60/115

Custom Patterns

Patterns tailored to your domain

Patterns for your framework(s)

Customized versions of stock patternsEtc.


61/115

Templates

Together supports two levels of patterns

1. SciPattern classes use Together

ControlCenters OpenAPI, written in Java,

highly configurable/extensible

2. Templates simple token replacement

approachpublic class %Name%{

public static void main (String[] argv) {

System.out.println(%Message%");

}

}


62/115

Documenting Pattern UsageBetter Software Faster suggestion


63/115

Pattern Harvesting


64/115


65/115

Jeff De Luca on Inspections

http://www.featuredrivendevelopment.com/node/view/566

Inspections are one of the mosteffective

defect removal techniques. Testing isone of the leasteffective defect removaltechniques. We know this frommeasurements; it isn't speculation. And

yet, what do most organizations do?They test. What do most organizationsnotdo? They don't inspect. Why is this?

Automate Low Level


66/115

Automate Low-Level

Inspections Software tools are very effective at finding certain types of

defects [They] are much faster and more accurate(Gilb, p.12)

Deep and precise parsing of source

Saves time and budget

Separation of concerns:- Computers excel at low-level inspection and counting

- People do not- People excel at business logic and design inspection

- Computers do not

Rich Gronback, Software Remodeling


67/115

Audits


68/115

Metrics


69/115


70/115

2. Practices of MDD


71/115

Reverse Engineering:


72/115

Reverse Engineering:effects on documentation generation

Automated documentation generation is based on

reverse-engineered models

Garbage in, garbage out

Configurable projects are key

Set parsing levels Dependency checking

Associations


73/115

2. Practices of MDD


74/115

Generators

Generative Programming

Domain Engineering

Product-Line PracticesUsage scenarios

Generators available now


75/115

Generative Programming

Generative programming is at the heart ofthe concept

Generative programmings goal is to

move away from single solutions toward

automated manufacturing of varieties of software.

Krzysztof Czarnecki and

Ulrich W. Eiseneckers book

is required reading


76/115

Domain Engineering

What if you could preserve your past

experiences building software systems?

Domain Engineering does exactly that AND

includes a structure for reusing work

products.


77/115

Conventional vs Domain

EngineeringSoftware Engineering Domain EngineeringRequirements Analysis

Produces requirements for one system

Domain Analysis

Produces reusable, configurablerequirements for a class of systems

System Design

Produces design of one system

Domain Design

Produces reusable design for a classof systems and a production plan

System Implementation

Produces system implementation

Domain Implementation

Produces reusable components,infrastructure and production process

Table 2-4, p57 Generative Programming


78/115

Product-Line Practices

Domain Engineering covers

Development of reusable assets

Production plan for producing systems reusing

those assets

Product-Line Practices provide

Management and organization Enable Domain Engineering processes

Provide a feedback loop between them


79/115

Usage scenarios

DTD generator

XSD generator

Entity Relationship Diagrams Logical Physical

OR Mapping tools Including Hibernate (model data specific);

Dialog Generators Is it better to wrap a dialog behind an API or generate them?

Both accelerate development no more fighting with layoutmanagers, hand-crafting dialogs to meet UI guidelines, etc.

Generated dont require maintaining the API, extending the APIwhen changes occur, etc.


80/115

2. Practices of MDD


81/115

references

www.omg.org

www.uml.org

www.mda.orgwww.modelbased.net

www.mdsd.info

http://www.prakinf.tu-ilmenau.de/~czarn/


82/115

3. MDA Overview


83/115

According to the Object Management Group (OMG):

MDA provides an open, vendor-neutral approach to

the challenge of business and technology change.

MDA aims to separate business or application logicfrom underlying platform technology.

Platform-independent models can enable intellectual

property to move away from technology-specific code,

helping to insulatebusiness applications from

technology evolution, and further enable

interoperability.

What is MDA?


84/115

The Benefits of MDA

Portability

Insulation from underlying technology change

Productivity

Code generation Communicate visually, thereby reducing complexity

Cross-Platform Interoperability

Generated bridges

Easier Maintenance and Documentation

Design artifacts become development artifacts


85/115

MDA is not a single specification, but a collection of related OMG

specifications:

Unified Modeling Language (UML) 2.0

Infrastructure

Superstructure Object Constraint Language (OCL)

Diagram Interchange

Profiles

Meta-Object Facility (MOF)

XML Meta-Data Interchange (XMI) Common Warehouse Meta-model (CWM)

Query View Transformation (QVT)

What Comprises MDA?


86/115


87/115

Note the industry verticals MDA is not intendedto be a general purpose model-to-code solution.

The MDA Logo


88/115


89/115

Transformations

This is the challenge for MDA!

Inspired by existing CWM transformation technology

MOF2 Core will align basis of UML and CWM

Query, View, Transformation specification is needed

At present, QVT is MIA

A record oftransformation isrequired to maintaintraceability andsynchronization.

M d l M ki


90/115

Model Marking

TransformationMarks are specific to a transformation Can be a stereotype in a profile, for example


91/115

Machine Code

Impossible?

The Abstraction GapMiddleware makes MDA a potential reality

Level of

Abstraction

Generators

1

0..*

security

mortgages

1

0..*

borrower

mortgages

10..*

ownerhouses

House

-value:Money

Person

-ssn:Integer

-salary:Money

+getMortgage(sum:Money,security:House):Mortgage

Mortgage

-principal:Money

-monthlyPayment:Money-start:Date

-end:Date

Machine Code with OperatingSystem

Impractical?3GL with Operating System

Unlikely?3GL withMiddleware

Practical(ly)Middlewarewith

Framework

Today!

A

b

stra

ct

io

n

G

a

p


92/115

What About SOA and BPM?Business Process Execution Language for Web Services

(BPEL4WS)

An XML standard for defining business processes withWeb Services

Provides high level of abstraction lends itself to

generation from models Negligible abstraction gap

UML Profile for Automated Business Processes Allows UML Class and Activity diagrams to model BPEL

Generate WSDL, BPEL and XSD Schema

Business Process Definition Metamodel being developed UML2-based metamodel with profile for BPD withmapping to BPEL4WS

Model and Code


93/115

Model and Code

SynchronizationForward Engineering Only The ultimate goal (?)

Need Action Semantics

Done in real-time and embedded systems today!Partial Round-Trip Engineering

Protected blocks for code

WYSIWYG GUI tools have done this

Full Round-Trip Engineering

Changes reflected up and down layers of abstraction

Necessary to wean programmers off 3GLs?


94/115

Building Better Model[er]s

As models move from design artifacts to

development artifacts:

Casual modelers will need to be upgraded

Rigorous models required for generation

Model validation becomes more important

Model repositories will be needed


95/115

MDA Summary

MDA is a collection of many specifications

Many of which are incomplete at present

MDA has promise

MDA is no silver bullet

The jump from 3GLs to MDA is considerably

longer than from Assembly to 3GLs

MDA can be done with agility

Waterfall not prescribed

MDA will require improved model(er)s


96/115

3. MDA Overview

MDD with Together


97/115

MDD with Together

ControlCenter

Use Design language to model requirements and

domain model (CIM & PIM)

Refine computational portion in PIM package

Export to target language project (e.g. Java, C#,C++)

Apply design patterns and elaborate design (PSM)

PSM and Code model maintained in sync with

LiveSource

Support of the Latest


98/115

Support of the Latest

StandardsCurrent work in progress: UML 2 support in development

OCL 2 support in development

XMI 2 support in development

Diagram Interchange support in development

JMI-based metamodel support (JSR-040)

Java-based transformation engine for QVT UML Profile support in development

Custom profile definition to be supported

Improving the


99/115

Improving the

Modeling Experience

Look for future support in Together for:

Expanded modeling capabilities

Cater modeling environment to role

Graphical view of metamodels

Modeling helpers and tutorials

Model-level audits and metrics

Validate models for transformation

OCL expression validation Transformation definition samples for

extensibility

MDD with Together


100/115

MDD with Together

TomorrowTogether

Designer

PSMCode LiveSourceCode Audits & MetricsEmbedded IDE Integration

PIMPSM TransformationsModel Audits & MetricsOpenAPIMulti-Language, Next GenerationTogether ControlCenter

RequirementsCIMDocumentation GenerationStrong CaliberRM integrationLightweight, standalone modeling

Together

Architect

Together

Developer

Model-Driven Development

Design-Driven Development

Industry Support in


101/115

y pp

modeling & MDA


Industry models

IAA

eTOM

etc

Industry frameworks

C4ISR Zachman

etc


102/115

Model Accessibility

Several possibilities:

Proprietary metamodel API

Java Metadata Interface (JMI)

Defined by JSR-040

Eclipse Modeling Framework (EMF)

Corresponding UML2 project

Internally, Together utilizes own metamodel

Known as Entity model

Full UML2 metamodel implementation unrealistic

Will be wrapped with standard JMI API for access

Done with on-the-fly model transformations

Query View


103/115

Q y

Transformation (QVT)

No specification available yet

No standard way to define a

transformation

OMG issued RFP on April 10, 2002

8 submissions, with 2 main groups:

QVT-Merge Group

Compuware/Sun Microsystems

Open Source


104/115

p

Transformers

Generative Model Transformer (GMT) Eclipse project (vaporware, JUUT-je prototype, UMLX 0.0) XMI-based (XMI+XMIXMI, XMIXMI, XMItext) Transformations based on textures

Patterns specified in unambiguous UML-based format

AndroMDA Builds on XDoclet, utilizes Velocity template engine Takes UML XMI file input and generates output using cartridges Current cartridges: Java, EJB, Hibernate, Struts Generates no business logic

Jamda Takes UML XMI file as input, using Jamda profile

Java-based code generators Generated class definitions added to UML model before codegen Currently J2EE-centric

Others: UMT-QVT, QVT-Partners; Open Generator FrameWork, etc.

http://www.amdromda.org

http://jamda.sourceforge.net

http://www.eclipse.org/gmt

Model Transformation
http://www.amdromda.org/http://jamda.sourceforge.net/http://www.eclipse.org/gmthttp://www.eclipse.org/gmthttp://jamda.sourceforge.net/http://www.amdromda.org/


105/115

Model Transformation

ResearchOCL-based transformations Input and output patterns defined in OCL

Prolog-based engine Identifies input pattern in source model

Generates output pattern in target model

Rule-based transformations Rules declared in XML

Model access and transform via JMI API

Batch processing of model, with potential incremental approach

Pattern-based transformations

Transformation declared with metaclass and OCL

Traverse modelexamine constraintsapply pattern to targetmodel

Technique used in current Together pattern technology


106/115

Model Validation

Current audits & metrics apply only to source model

Source Code Interface (SCI) to code model

Model audits use JMI API

Access and evaluate OCL constraints in model Audits themselves can be written in OCL

OCL validator accesses model constraints with JMI API

All validation results utilize common interface

Unified format for analysis


107/115

What you can do now

Refine your models:

Leverage UML profiles where appropriate

Specify all types

Specify all multiplicities

Name all associations and association ends

Clean up dangling model elements

Make models semantically complete Declare constraints in OCL


108/115

What you can do now

Treat models as if they were development artifacts

Not as throwaway design relics

Learn UML2 and OCL

OMGs UML2 Certification Program

Avoid UML constructs not supported by MOF:

N-ary associations

Qualified associations

Association classes

Stop hand crafting XSDs, DTDs, and Java APIs for metadata

Generators exist today!


109/115

3. MDA Overview


110/115

Overview of Future Support

Support of the Latest Standards

As they become available

Improve the Modeling Experience

Align Products with MDA Roles & Activities

Support Industry Models and Frameworks

Increase Generative Capabilities and

Customizability

Model access, validation, transformation

Improving the Modeling


111/115

p g g

Experience


Expanded modeling capabilities

Cater modeling environment to role

Including the ability to get a graphic view ofmetamodels

Modeling helpers and tutorials

Model-level audits and metrics

Validate models for transformation Transformation definition samples for

extensibility

MDD with Together


112/115

g

Tomorrow (first of two)

Current ability of developers to work with PSMs will grow

New capabilities for Analysts with Together Designer

To create Problem Domain CIMs

To create models for a library maintained by Architect

PIMs developed with Together Designer

Can be based on pre-existing Models from Library

Use OCL2 for constraint definition

Apply UML Profiles to model

Rely on model level audits for quality

Code generated maintained in sync with PSM

MDD with Together


113/115

g

Tomorrow (continued)

With Together Architect, shops will have model libraries

Models of Platforms, of Business Process, and Apps

Ability to combine and transform models

Access model information programmatically

Maintain relationships among models

Define and modify metamodels graphically

Create and maintain libraries of Model Transformations

A catalog of PIMPSM transformations available

Define and add your own, or purchase new ones

Validate a service oriented architecture against

The business process it should automate


114/115

D. Frankel, Model Driven Architecture. Applying MDA to

Enterprise Computing. Indianapolis, IN: Wiley, 2003.

S. Mellor et al, MDA Distilled. Principles of Model-Driven

Architecture. Boston, MA: Addison-Wesley, 2004.

A. Kleppe et al, MDA Explained. The Model Driven

Architecture: Practice and Promise. Boston, MA:

Addison-Wesley, 2003.

J. Miller et al, MDA Guide Version 1.0. Needham, MA: OMG,

2003.

R. Hubert, Convergent Architecture: Building Model-Driven

J2EE Systems with UML. New York, NY: 2002.

References


115/115

4. Questions and Answers

Documents

32441_10061845_S-OBJECT ORIENTED ANALYSIS AND DESIGN