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

Standards-Based Executable UML®
Today’s Reality and Tomorrow’s Promise
Object Management Group® Webinar
Ed Seidewitz
Director of Research and Development
nMeta LLC ● http://www.nmeta.us
ed@nmeta.us ● @seidewitz
8 March 2017
Copyright © 2017 Ed Seidewitz

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 Charts
1988, 1998
Real-Time OO Modeling
(ROOM)
1994
Became Executable /
Translatable UML (xtUML)
Incorporated into UML as
State 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
Environment
Other 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/

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

More Related Content

What's hot (20)

Similar to Standards-Based Executable UML: Today's Reality and Tomorrow's Promise (20)

More from Ed Seidewitz (10)

Recently uploaded (20)

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