In London
on June 10, 2003, as a BCS student volunteer I attended a day long conference
tutorial tracks on “Executable Translatable UML” and “MDA Distilled” by Stephen
J. Mellor. This one day workshop was organized by LogOn technology transfer,
now Lufthansa Technical training and OMG (Object Management Group). Mr. Mellor is founder and Vice President of Project Technology, Inc. and an enthusiastic visionary who, like most of us, sees UML as a
universal language of design. However, his vision doesn’t stop
here; he also envisions models to be actual working systems, functioning
prototypes as parts of big complex machines. During the tutorial, Mellor focuses
on how an architect can design an application which would be flexible as a UML
diagram and concrete as a prototype application. He demonstrated, what seemed
to be an early stage customized application designer, to actually compile,
modify and run the “design”.
Now After about three years, Gerald Walsh of Microsoft recently
spoke to our local .NET user group, SGV.NET
on Windows Workflow foundation. WF, as Microsoft defines is “the new programming
model, runtime components, and tools for quickly building workflow-enabled
solutions on the Windows platform.” is an
excellent effort towards implementation of model driven architecture. WinFX,
loosely speaking would be “BizTalk built-in with OS, without the B2B adapters.”
From the work flow prospect it is
described as “Windows Workflow Foundation includes support
for both system workflow and human workflow across a wide range of scenarios
including: workflow within line of business applications, user interface
page-flow, document-centric workflow, human workflow, composite workflow for
service oriented applications, business rule driven workflow and workflow for
systems management”.
So what’s wrong with
this picture?
Standardization.
With C# being an ECMA standard and Microsoft moving towards
Office 12’s open document formats, it might have been wiser if UML was the main
document standard where a work flow is
devised. The work flows are based on activity, process flow, state machine,
sequence and component diagram. The runtime engine, like now, would support the
corresponding underlying code activities. However, in the current picture, it’s
all proprietary with several VS.NET dependencies.
Model based code generation is fairly common. It’s not
rocket science since Rational has been doing it for a long time; however AFAIK,
WinFX would be the first platform level attempt of implementing workflow
engines. The question may rise that If Microsoft makes it open standard, who
would buy the IDE? All that lost revenue? Another fallacy; Microsoft’s business
model is primarily based on platform sales revenue as compared to IDE sales and
workflow is part of the platform (WinFX will be available for Win2k3, Vista
etc). Opening it up to the world would it much more attractive to developers
and business systems analysts who would now be able to unleash the power their
designs and see their flow charts executing.
Having said that, I see WinFX as an excellent platform
enhancement for resolving today’s workflow design blues. It will escalate SOA,
definitely drive more and more component oriented design and will enhance
reusability. An ideal opportunity for third party leverage and component
vendors to develop plug and play components for the work flow models; you see
the blue thing up there, that’s the limit.
References
The Object Management Group
Executable
UML: A Foundation for Model-Driven Architecture, Mellor and Balcer,
Addison-Wesley, 2003
MDA
Distilled: Principles of Model-Driven Development, Mellor, Scott, Uhl and
Weise, March 2004.
Executable UML: Diagrams for the Future
Track descriptions
(Courtesy OMG / LogOn)
OMG Track 1 description: Executable Translatable UML is
here. Although it is possible today to add code to UML models and then execute
them, in so doing you must make a series of decisions about implementation that
may not be correct, appropriate or even known. XTUML models systems at a higher
level of abstraction, thus avoiding the costs involved in a premature design,
and offering the benefits of early verification through simulation. XTUML is
independent of the software platform, which means that a model can be
translated into any set of implementation technologies and languages the
developer chooses. The choices about implementation are captured separately in
a model compiler, an open set of archetypes that translate the UML model
directly into efficient code. This offers the ability to delay implementation
decisions until the last minute. This presentation describes the components of
executable translatable UML and how they fit together. It also describes how to
translate the models into code.
OMG Track 2 Description: Model-driven architecture is an OMG
initiative that promises to deliver standards that will enable and encourage
model-driven development, this making models assets, in contrast to code-driven
development in which code is an ongoing expense. The keys to this technology
are the ability to model systems at a high enough level of abstraction that
decisions about implementation technologies can be deferred, and the ability to
weave together such models‹including models of implementation technologies and
code‹into a system only when the system is ready to be deployed. This tutorial
will explain the fundamentals of MDA; what the basic technologies are; how they
fit together; what standards are already in place; and what still needs to be
done to realize the vision.
Speaker’s bio: Stephen J. Mellor is an
internationally recognized in pioneer in creating effective, engineering
approaches to software development. In 1985, he published the widely read
Ward-Mellor trilogy Structured Development for Real-Time Systems, and in 1988,
the first books defining the concepts of object-oriented analysis. Steve has
just completed Executable UML: A Foundation for Model-Driven Architecture and
is currently authoring his next book Model-Driven Architecture Distilled. Steve
founded Project Technology, Inc. in 1985 to facilitate effective software
development by automating model-driven development using Executable and
Translatable UML (xtUML).