Today, Ed Seidewitz (also @seidewitz ) explains us the ups and downs of the inclusion of an Action Language as part of the OMG UML Specification. Thanks a lot Ed for this very interesting story (and not only for the technical content)!. Ed is Vice President of Model Driven Architecture Services at Model Driven Solutions . He is a long-time participant in the UML standardization process and member of the UML Revision Task Forces. He was a contributor to the UML 1.5 Action Semantics standard, editor of the fUML specification and primary author of the Alf specification.
And the story begins …
Early in 1998, Stephen Mellor came to the Object Management Group (OMG) with a mission. Stephen was already well known for the methodology he developed with Sally Shlaer in which objects are given precise behavior specifications using state machine models annotated with a high-level action language. Now the OMG had just adopted the Unified Modeling Language (UML), and Stephen wanted to suggest that OMG issue a request for proposals for a standard action language for UML.
This was the first OMG meeting that Stephen had attended (coincidentally it was my first one, too!), and he was impressed at how enthusiastic the other attendees were to see him there and how positively his ideas were received. So he returned at the next OMG meeting (they were held every other month in those days!) ready to start work on the action language RFP. But, of course, it didnt end up being so simple.
The OMG is a membership organization, and it isn’t the same subset of the membership at every OMG meeting. So, while Stephen was ready to continue where things left off at the last meeting, the attendees at the second meeting received him much more skeptically than those at the first. Did it really make sense to add such a textual modeling language to primarily graphical UML? they asked. What did it mean to make action semantics precise, anyway? and Should models really be executable at all?.
In the end, in late 1998, the OMG finally issued the RFP for Action Semantics for the UML, whose objective was to extend the UML with a compatible mechanism for specifying action semantics in a software-platform-independent manner. But this RFP specifically did not ask for a standard textual action language notation to embody the new semantics, only including an optional requirement (a peculiar OMG oxymoron) for a non-normative mapping of the proposed action semantics to one or more action language syntaxes (the RFP submission ultimately included mappings to three action languages in already existing products from submission team members). This RFP eventually led to the expanded action metamodel in UML 1.5, adopted in 2002, but no standard action language was ever adopted for the UML 1.x series.
UML 1.5 was the last revision of UML 1. However, the action metamodel in UML 1.5 had a strong influence on the abstract syntax for actions in the new UML 2.0, adopted in 2005. Nevertheless, the specification of the semantics for actions in UML 2.0 was not really precise. A formal semantic specification had been included in every version of the submission to the old Action Semantics RFP except the last, when the consensus of the OMG Analysis and Design Task Force (ADTF), in charge of the RFP, was that the community was not ready for this level of formalization. So the action semantics in both UML 1.5 and UML 2.0 were simply described in informal text and somewhat more loosely in UML 2.0 than UML 1.5, in fact.
In the meantime, the attitude of the OMG membership on executable models had continued to evolve. In 2003, OMG issued the first guide to its new Model Driven Architecture (MDA), which proposed making models primary artifacts in the system development process. But, with an MDA approach, it becomes increasingly important to make models more precise and to validate models before they become the basis for further development.
Of course, how to do that was exactly what Stephen had in mind when he first came to OMG (well before OMG actually codified MDA)! You make your models precise enough that they can be executed, so you can actually run and test them. And once the models are validated, you can deploy them, in an MDA fashion, to one or more implementation platforms, as necessary or, perhaps, even run the models themselves in production.
So, in 2005, even as UML 2.0 was being finalized, OMG issued the RFP for the Semantics of a Foundational Subset for Executable UML Models. The resulting Foundational UML (fUML) specification, adopted in 2008, provided the first precise operational and base semantics for a subset of UML encompassing most object-oriented and activity modeling. Finally, one had a standard for what it meant to execute a UML model, at least within this foundational subset.
The fUML specification still did not provide any new concrete surface syntax, however. Rather, it tied the precise semantics solely to the existing abstract syntax model of UML. But, at last, the OMG was ready for an action language standard. In 2008, as work on the fUML specification was finishing up, over 10 years after it was first suggested by Stephen Mellor, OMG issued an RFP for Concrete Syntax for a UML Action Language. And this time there was almost no opposition to it. Indeed, by the time the final submission to the RFP (known as the Action Language for fUML or Alf) was adopted by OMG in 2010, the ADTF was again positively enthusiastic about it but this time that enthusiasm carried through the evaluation of the submission and the subsequent adoption vote.
Stephen Mellor little knew when he first came to OMG that he was embarking on a 12 year journey to get a consensus on a UML action language. As one who has come along on that journey with him, I can say it has been quite a ride. However, now that the pieces are finally falling into place to do standards-based executable UML modeling, I think that a potentially much more rewarding journey is just beginning, as users start to use the interoperable tools that vendors are now developing based on these standards.
A subsequent post will have a little more to say about the new fUML and Alf standards themselves. Stay tuned!
ICREA Research Professor at Internet Interdisciplinary Institute (UOC). Leader of the SOM Research Lab focusing on the broad area of systems and software engineering. Home page.
I am a Plain Old Java Developer (POJD), UML does not play a role in my work. However, I have recently read a few books on Executable UML and I am very impressed by it.
It seems like only a matter of time before there is a full ‘programming LANGUAGE’ for specifying executable UML models.
Anybody know of any such language/textual syntax?…
Ted,
Hopefully, Ed´s next post (coming up soon!) will convince you that Alf is the UML Action Language you are looking for.
Alternatively, you can also take a look at Umple
Hi jordi,
I always love Ed’s strolls through the past, and they give fantastic insight into how the current state of affairs came out to be.
However, I seem to fall into the camp that executable UML is most likely a “Rube Goldberg”-ian attempt at somehow finding the silver bullet that can finally solve the “software crisis”.
IMHO, graphical modelling is about communicating various aspects of the design/architecture in question. Once you add executable semantics to models, then it is isomorphic to writing code in a high-level language … a far more easier and productive endeavour compared to obtruse modelling tools.
[couldn’t help touting my own horn]
Ted,
TextUML Toolkit is an Eclipse-based open source modeling toolkit that allows creating models with support for action semantics using a textual notation. See:
http://abstratt.github.io/textuml/readme.html
Rafael
I googled ALF and discovered that it’s a FULL blown LANGUAGE – I was thinking that it was ONLY a syntax FOR specifying the behavior OF operations – but you can specify entire models IN ALF – similar TO TextUML.
The NAME ‘Action Language for Foundational UML’ misled me – I wonder if my mistake IS common.
After glancing AT the specification FOR two minutes I can see that ALF has a lot TO recommend it…
… support FOR signals – that IS something that many other high-LEVEL languages ARE missing but IS a very important concept FOR making models WORK together
…inherently concurrent – ALF seems TO be inherently concurrent instead OF inherently sequential LIKE most languages.
…templates – can be used TO define parameterized types AND such
…activities – AS FIRST class entities
Wow…
Now… the xUML books talk about stitching UML models together IN an aspect-oriented way – I gotta go through the examples IN the books AND see if I can actually do that WITH ALF…
Ted —
You are exactly right: Alf is a complete language. However, not all of the submitters were entirely comfortable with that. The RFP allowed it, but the primary requirements were just for an action language to annotate graphical models.
So, in the end, the submission was still called an “action language” and the structural modeling features were made part of the optional “extended conformance” level. But they are still there in the spec!
And you hit on some of the key points that make Alf different than “just another programming language”. I think the “inherent concurrency” is going to be particularly important. Note that this is actually inherent in the underlying fUML activity semantics to which Alf maps.
(See also my subsequent post on fUML and Alf, which discusses this a little more.)
— Ed