Using Alf with Cameo Simulation Toolkit - Part 1: Basics

No Magic World Symposium, Allen TX
Ed Seidewitz
Model Driven Solutions, Inc. ● http://www.modeldriven.com
ed-s@modeldriven.com ● @seidewitz
Copyright © 2018 Ed Seidewitz
Using the Alf Action Language
with Cameo Simulation Toolkit
Part 1 – Basics

About me
Ed Seidewitz
Chief Technology Officier, Model Driven Solutions, Inc.
ed-s@modeldriven.com ● @seidewitz
• 30 years experience as a project manager,
architect, developer and modeler
• Involved with UML since version 0.8
• Developer of fUML and Alf Reference
Implementations and MagicDraw Alf Plugin
• Chair of the OMG fUML and Alf Revision Task
Forces; member of the UML Revision Task Force

Goals
Part 1 – Basics (Today)
• Learn the basics of the Alf action language for Executable UML.
• Use the Alf Plugin for MagicDraw.
• Practice using Alf with Cameo Simulation Toolkit.
Part 2 – Modeling (Wednesday)
• Model simulations using the Alf action language.
• Use Alf in class and state machine models in MagicDraw.
• Create and run simulations using Alf with Cameo Simulation
Toolkit.

Prerequisites (for Part 1)
• Participant
– Basic knowledge of class, activity and state machine modeling
using MagicDraw
– Some experience with model execution using Cameo Simulation
Toolkit
– General familiarity with programming/scripting (particularly in a
language like C++, Java, JavaScript, etc.)
• System (for hands-on exercises)
– MagicDraw 18.5
– Cameo Simulation Toolkit 18.5sp3
– Alf plugin 18.5
Install MagicDraw, CST and Alf Plugin on line or from USB stick

5
Installing the Alf plugin
Plugin documentation is available at:
https://docs.nomagic.com/display/ALFP185/Alf+plugin
Under Plugins
(commercial),
download / install the
Alf plugin v18.5.
Select Help ► Resource/Plugin
Manager to open the Resource/
Plugin Manager window.
 A new version will be
available for the 19.0
release.
Or click here to install
from USB stick.

Background

Executable UML
Executable UML is a (growing) subset of standard UML that can be
used to define, in an executable, operational style, the structural and
behavioral semantics of systems.
• Foundational UML (structural and activity models)
– http://www.omg.org/spec/FUML
• Precise Semantics of UML Composite Structure (PSCS)
– http://www.omg.org/spec/PSCS
• Precise Semantics of UML State Machines (PSSM)
– http://www.omg.org/spec/PSSM
• Action Language for Foundational UML (Alf)
– http://www.omg.org/spec/ALF
A textual surface representation for UML modeling elements with the
primary purpose of acting as the surface notation for specifying executable
(fUML) behaviors within an overall graphical UML model.
Alf Plugin

Why an action language?
• Graphical notations are good for…
Structural models
High-level behavioral models

Why an action language?
• …but not so good for detailed behavior
Full executability requires complete
specification of behavior and
computation. This is often much more
easy to specify using a textual notation.

Why not just use a scripting language?
• Scripting language:
No standard syntactic or semantic integration with UML
• Alf:
Full, standardized syntactic and semantic integration with UML
this.lineItems->remove(item)
this.totalAmount = Subtract(this.totalAmount, item.amount)
ALH.removeValue(self, "lineItems", item);
arguments = ALH.createList();
arguments.add(ALH.getValue(self, "totalAmount"));
arguments.add(ALH.getValue(item, "amount”));
ALH.setValue(self, "totalAmount",
ALH.callBehavior("Subtract", arguments));
Example using the MagicDraw-
specific Action Language
Helper API for JavaScript.

The basic idea: Alf maps to fUML
activity DoSomething(in input: Integer, out output Integer): Integer {
output = A(input);
return B();
}
Alf behavioral notation
maps to fUML activity
models.
The semantics of the Alf notation is
defined by its mapping to fUML

Hands On
Hello World

Create an Alf project
In the Alf folder,
select the Alf
template.
 The Alf template automatically
loads the Alf Library model and
sets Alf as the default language
for opaque behaviors, actions
and expressions.
Under Other,
select Project
from Template.
Select File ► New Project to
open the project creation window.
Create a Hello
World project.

Create the Hello World activity
Create a
new Activity.
Enter the Alf code in
the Alf editor window.
When the code is
correct, click Save.
 If the Alf editor window
is closed, you can open
it using Window ► Alf.

Executing the activity
Right click on the
Activity and select
Simulation ► Run.
Set Animation Speed
to the highest level…
…and click
here to run.
Output appears in
the console pane.

Basic Concepts

Assignment as data flow
a = +1;
b = -a;
a = A(a) + B(b);
Local names map to
forked object flows.
Subexpressions are
evaluated concurrently.
A re-assigned local
name actually maps
to a new flow.
 The literal “1” has type
Natural. The expression
“+1” has type Integer. The
expression “A(a) + B(b)” has
type Integer, which is not
compatible with Natural.
The local name a implicitly
gets the type Integer.
Statements map to structured
activity nodes with control flows
to enforce sequential execution.
a = 1;
a = A(a); ✗
type conformance

Using Alf for behaviors
lineItem = new LineItem(product, quantity);
this.lineItems->add(lineItem);
this.totalAmount = this.totalAmount + lineItem.amount;
Method of an operation
this.lineItems = checkOut.items;
Customer_Order.createLink(checkOut.customer, this);
this.datePlace = CurrentDate();
this.totalAmount = lineItems.amount->reduce '+';
this.SubmitCharge(checkOut.card);
Behavior on a state machine
battFrac = battCond / this.maxBattLevel;
gThrottle = Max(accelPos * (1-battFrac), this.maxGThrottle);
eThrottle = Max(accelPos * battFrac, this.maxEThrottle);
Body of an action

Using Alf for expressions
Activity Edge Guards
State Machine Transition Guards

Hands On
Stopwatch

Open the StopWatch sample project
…
Click Samples on
the Welcome Screen
Under Simulation,
choose the StopWatch
sample project.
 Select File ► Save Project As…
to save a local copy of the project
before continuing.

Setup the project for Alf
Remove the existing
Project Usage for
fUML_Library.
 This part will not be
necessary in v19.0.
Select Tools ► Alf ►
Load Library to load
the Alf Library.

Open the StopWatch state machine

Replace the ready state behavior
Open the Specification
window for the ready
state.
Under Entry, change
the Behavior Type to
Opaque Behavior.
 Be sure to select the ready
state as a whole, not just the
line for the entry behavior.

Replace the reset timer activity
with Alf code
 Be sure to click on the text
for the entry behavior, not
the entire state.
Click on the
entry behavior…
replaced by
 The use of the prefix this
is required to access an
attribute value in Alf.
…and enter the
code into the Alf
editor window.

Show the Alf code on the state machine
diagram
Open the Symbol
Properties window for
the ready state.
Set the Opaque
Behavior Display Mode
property to Body.

Coming in v19.0!
Syntax-aware editing
of Alf code in opaque
body editors.

Replace the Increase time activity with Alf
code
replaced by
 The ++ operator
increments its argument.

Executing the StopWatch model
Right click on the
StopWatch class and select
Simulation ► Run.
Start the simulation, then
trigger the start signal.
Output is displayed
in the console tab.
The current state
machine configuration
is animated.

Sequences

Sequences
activity GetReadings(in sensors: Sensor[*]): Integer[*] {
readings = sensors->collect sensor (sensor.reading);
return readings;
}
The input parameter has
an unordered set of
values (by default).
Object flows always carry
ordered sequences of
values.
Values are handled one
by one within the
expansion region.
The read actions
happen concurrently.
The result is a sequence
ordered respective to the
input sequence.
The return parameter
gets an unordered set
of values (by default).
 The Alf on the left could be
written more simply as:
return sensors.reading;
The local name reading
implicitly gets the type Integer
and the multiplicity [0..*].
 Arbitrary sequences cannot
be assigned to local names
with multiplicity [0..1].
reading = -1;
readings = reading;
reading = readings;
Implicitly gets the multiplicity [0..1]
A single value is really just a
sequence of length 1.
✗ multiplicity conformance

Null as the empty sequence
A LiteralNull is intended to be used to explicitly model the lack of a value.
In the context of a MultiplicityElement with a multiplicity lower bound of 0,
this corresponds to the empty set (i.e., a set of no values). It is equivalent
to specifying no values for the Element.
null = any [ ] { }
From the UML 2.5 specification (clause 8.2.3):
The Alf interpretation: null is the (untyped) empty sequence
sensors = null;
sensors.readings;
WriteLine(null);
WriteLine(name ?? "no name");
“null” can be assigned to any target with
a multiplicity lower bound of 0.
This is not an error. It is equivalent to
sensors->collect sensor (sensor.reading);
which evaluates to “null”.
 An argument for
a parameter of
multiplicity 1..1
cannot be null.
✗
multiplicity conformance
A null-coalescing expression can be used
to provide a non-null “default value”.

Hands On
Reversing a Sequence

Create the Reverse project
Create a new project
using the Alf
template, as before.

Create the Reverse activity diagram
Create a new
Activity Diagram.

Add activity parameter nodes
Leave the parameters
untyped.

Add Alf code in opaque actions
Click on the opaque
action to enter code in
the Alf editor window.
The CompiledRepresentation
stereotype records the executable
activity compiled from the code.
Click on the opaque action and
select Symbol Properties to turn
off stereotype display.
Click here to make this the default.
Select Expert mode,
if necessary.
 If you are using SysML, be careful
to us the UML Boolean type, not
the SysML Boolean type.

Fill in the activity model
Using an expression here is a
shorthand for the statement
result = seq->isEmpty();
Alf in an Opaque Action
can access pins as
local names.
 Guards must be entered
as Literal Specifications.

Coming in v19.0!
Alf activity edge
guards using
decision input
values.

Write a TestReverse activity
Iterative for loop
Sequence construction
expression
Cast expression Null-coalescing expression
 The cast expression is required because the result of
Reverse is untyped. The null-coalescing expression
is required because a cast can result in null.

Testing the Reverse activity
Right click on
TestReverse and select
Simulation ► Run.
Click here to execute.
Make sure the slider is
all the way to the right!
This is the expected result.

Bonus: Writing Reverse entirely in Alf
activity RecursiveReverse(in seq : any[*] sequence) : any[*] sequence {
return seq->isEmpty()? null:
seq->excludeAt(1)->RecursiveReverse()->including(seq[1]);
}
activity IterativeReverse(in seq : any[*] sequence) : any[*] sequence {
result = null;
n = seq->size();
for (i in 0..n-1) {
result->add(seq[n-i]);
}
return result;
}
The arrow notation (sequence operation
expression) can be used with any behavior
that has a sequence as its first parameter.
Conditional-test expression
Remember that null is the
empty sequence.
add is an “in place”
collection function.

Using Alf with Cameo Simulation Toolkit - Part 1: Basics

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (8)

Similar a Using Alf with Cameo Simulation Toolkit - Part 1: Basics

Similar a Using Alf with Cameo Simulation Toolkit - Part 1: Basics (20)

Más de Ed Seidewitz

Más de Ed Seidewitz (19)

Último

Último (20)

Using Alf with Cameo Simulation Toolkit - Part 1: Basics

Notas del editor