Hands On With the Alf Action Language: Making Executable Modeling Even Easier

Hands On With the Alf Action Language

Making Executable Modeling Even EasierNo Magic World Symposium, Allen TX

Ed Seidewitz

Director of Research and Development

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

[email protected] ● @seidewitz

Copyright © 2017 Ed Seidewitz

23 May 2017

http://www.nmeta.us/

mailto:[email protected]

Goals

• To learn the basics of the Alf action language for Executable UML.

• To learn how to use the Alf Plugin for MagicDraw.

• To practice hands-on using Alf with Cameo Simulation Toolkit.


Prerequisites

• 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.4 or 18.5

– Cameo Simulation Toolkit 18.4 or 18.5

– Alf plugin v18.5


4

Installing the Alf plugin


Plugin documentation is available at:

https://docs.nomagic.com/display/ALFP185/Alf+plugin

Under Plugins (no

cost), download/

install the Alf plugin

v18.5 beta.

Select Help ► Resource/Plugin

Manager to open the Resource/

Plugin Manager window.

Commercial release

planned for v19.0 in

Q4 2017.

https://docs.nomagic.com/display/ALFP185/Alf+plugin

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

http://www.omg.org/spec/FUML

http://www.omg.org/spec/PSCS

http://www.omg.org/spec/PSSM

http://www.omg.org/spec/ALF

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 OK.

Right-click on

the Activity and

select 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 operationthis.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.

Select File ► Use Project ►

Use Local Project to open the

Use Project window.

From the modelLibraries

directory, choose

Alf-Library.mdzip.

Click Finish to

load the 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 line

for the entry behavior, not

the entire state.

Right click on the entry

behavior and select Alf.

Enter the code

into the Alf

editor window.

replaced by

The use of the prefix this

is required to access an

attribute value in Alf.

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.

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

Address Book


Create the Address Book project


Create a new project

using the Alf

template, as before.

Create the Address Book class model


Make sure these Entry

attributes are public.

Give this association

end a multiplicity of *.

Create Address Book and Entry operations


This is a constructor operation.

Create it in the usual way, and then

apply the standard Create stereotype.

Create the Entry constructor method


Right click on the Entry

operation and select

Create Method ►

Behavior to open this

selection window.

Choose either

Activity or

Opaque Behavior.

Right click on the

Entry operation again

and select Alf to open

the Alf editor.

Enter the Alf code to

initialize an Entry.

Create Address Book operation methods


Create methods for

the AddressBook

operations, and then

enter the Alf code

shown for them.

A select expression is used to filter

a sequence based on a condition.

The index [1] ensures that at most

one value is selected.

This expression will return either a

single value or null, as required by

the return multiplicity of 0..1.

The constructor

operation is used when

creating an instance of

the Entry class.

The braces { } are

required in if statement

clauses in Alf.

Test the Address Book model


Create an

AddressBookTest

activity with the

Alf code below.

Run the activity

and see if it works!

A class can also be instantiated without

a constructor, as in new AddressBook().

The ?? (null-coalescing) operator is

used here because get has return

multiplicity 0..1 and the + operator

requires argument multiplicity 1..1.

Hands On With the Alf Action Language: Making Executable Modeling Even Easier

Software

Transcript of Hands On With the Alf Action Language: Making Executable Modeling Even Easier