Standards-Based Executable UML: Today's Reality and Tomorrow's Promise

Standards-Based Executable UML®

Today’s Reality and Tomorrow’s PromiseObject Management Group® Webinar

Ed Seidewitz

Director of Research and Development

nMeta LLC ● http://www.nmeta.us

[email protected] ● @seidewitz

8 March 2017

Copyright © 2017 Ed Seidewitz

http://www.nmeta.us/

mailto:[email protected]

Traditional Modeling is Extra Work


Developers provide feedback

to the architects (maybe)

It is hard to validate the correctness of the models before development.

The developers may not follow the models, without providing feedback.

It is hard to keep the models and development artifacts in sync during

development (and maintenance).

Architects give models to developers

Developers

create artifacts

based on the

models

(maybe)

Architects

create the

models

Executable Modeling Just Works!


The models are validated in a

development/test environment

The models are deployed in a production

environment

Developers

create fully

executable

models

Developers iteratively execute,

test and update the models

Agile development…with executable models!

This is not a new idea…

Shlaer-Mellor 1988, 1991

Harel State Charts1988, 1998

Real-Time OO Modeling (ROOM)

1994

Became Executable / Translatable UML (xtUML)

Incorporated into UML asState Machines

Became UML for Real Time (UML/RT)


But it wasn’t standardized before…


1997

1998

2003

2005

2010

2011

2018

2017

2016

2015

Action Semantics for the UML RFP

Semantics of a Foundational Subset

for Executable UML Models RFP

Foundational UML (fUML) 1.0

fUML 1.2.1 (current version)

fUML 1.3 (in process)

fUML 1.4 (planned)

UML 1.1 (first OMG version)

UML 1.5 (with action semantics)

UML 2.4.1

UML 2.5 (current version)

UML 2.0

UML 2.3

Precise

Semantics of

Composite

Structure

(PSCS)

Precise

Semantics of

State Machines

(PSSM)

Precise

Semantics of

Interactions

Executable UML Standards (current/in process/planned)

Precise

Semantics of

Profiles

Precise

Semantics of

Time


Action Language for fUML (Alf)

Foundational UML (fUML)

Executable subset of standard UML that can be used to define, in an

operational style, the structural and behavioral semantics of systems

v1.2.1 (2015) / v1.3 (2017) / v1.4 (2018)

Textual surface representation for fUML

models, particularly executable behaviors

v1.0.1 (2013) / v1.1 (2017) / v1.2 (2018)

An extension of fUML for the execution

of composite structure models

v1.0 (2015) / v1.1 (2017) / v1.2 (2018)

An extension of fUML for the

execution of state machine models

beta (2016) / v1.0 (2018)

Possible future standards

Customer Order Example


: Why can’t this be our code?

This is a structural model of an

order as a set of product line

items, for a specific customer.

…and of asynchronous

behavior for charging the

order to a credit card.

But it is also a model of

synchronous behavior for

managing an order….

✓

✓

✓

These are

active classes.

Using Alf for Operation Methods


«Create» Order

this.datePlaced = datePlaced;

this.cardToCharge = cardToCharge;

Order_Customer.createLink(this, customer);

return this;

cancel

Order_Customer.destroyLink(this, this.customer);

addProduct

lineItem = new OrderLineItem(product, quantity);

this.lineItems->add(lineItem);

this.totalAmount =

Add(this.totalAmount, lineItem.amount);

removeProduct

items = this.lineItems->

select item (item.product == product);

this.lineItems->removeAll(items);

this.totalAmount = Subtract(this.totalAmount,

items.amount->reduce Add ?? ToMoney(0.0));

items.destroy();

Alf semantics are

fUML semantics.

Using Alf as a Textual Notation for Activities


An Alf compiler can create

an activity model for you –

better than by hand

Using Alf for State Behaviors


State machine transitions are

triggered by the receipt of

asynchronous signals.

Entry behaviors are executed

when a state is entered.

This Alf statement creates a

new credit card charge object

and begins its active behavior.

This Alf statement sends a

signal to the customer object.

Executable UML for Multi-Core Programming

Traditional processor architecture

Single processor

Local registers / cache

Remote memory

Multi-core processor architecture

Many processors

Much local memory

Global/distributed memory

Concurrency is

natural here

Traditional modeling language

Things / Relationships

Events / Behaviors

Communication

Concurrency is

natural here

Traditional programming language

Functions / procedures

Local variables / stack

Heap memory

Concurrency is

NOT natural here!

Executable

UML

Executable UML Ecosystem

Execution/Simulation

Engine

Model Development

EnvironmentOther Tools

Target Platform


Enabled by

standardized

executable modeling.

Some Executable UML Implementations

Open Source

Modeldriven.org (Reference) Implementations (fUML, Alf)http://fuml.modeldriven.org, http://alf.modeldriven.org

Eclipse Papyrus UML Tool (fUML, PSCS, PSSM, Alf incubation)https://wiki.eclipse.org/Papyrus/UserGuide/ModelExecution

Used in Demo

No Magic MagicDraw (fUML, PSCS, PSSM, Alf beta) https://www.magicdraw.com/simulation

Others

List of Executable UML Tools http://modeling-languages.com/list-of-executable-uml-tools/


http://fuml.modeldriven.org/

http://alf.modeldriven.org/

https://wiki.eclipse.org/Papyrus/UserGuide/ModelExecution

https://www.magicdraw.com/simulation

http://modeling-languages.com/list-of-executable-uml-tools/

Standards-Based Executable UML: Today's Reality and Tomorrow's Promise

Software

Transcript of Standards-Based Executable UML: Today's Reality and Tomorrow's Promise