Home > Articles > Programming > Windows Programming

Agile MDA

  • Print
  • + Share This
Like this article? We recommend

Like this article? We recommend

Translating a Model

Executable UML defines groupings of data and behavior ("classes"), the behavior over time of instances ("state charts"), and precise computational behavior ("actions"). The reason for the quotation marks is that executable UML does not prescribe implementation. Rather, a "class" in executable UML represents a conceptual grouping of data and behavior that may be implemented as a class, or it may be implemented as a C struct and a set of associated functions, or as a VHDL1 entity. A "class" doesn't have to be implemented as a class. Consequently executable UML is a software-platform-independent language that can be translated into any target. For this reason, we also use the word "translatable" as well as "executable."

Models, Models, Models

There are at least three meanings of "model," and each one denotes diverse usages and connotes different processes. One denotation for the word "model" is a sketch. We sketch out the shape of a wing on the back of a beer mat, show a few lines indicating air flow, and write an equation or two describing how the two interact. The sketch is not complete, nor is it intended to be. The purpose of the sketch is to try out an idea. The sketch is neither maintained nor delivered.

Agile exponents are willing to sketch out their classes and use cases, sometimes called "stories," and perhaps even use UML to do it. There's no fight here: even the most extreme use sketches to outline their plans for the code.

A second denotation for the word is the model as blueprint. The physical model of the airplane in a wind tunnel is one example; more commonly, we think of a blueprint as a document describing key properties needed to build the real thing: the blueprint is the embodiment of a plan for construction.

The connotations of a model-as-blueprint cause conflict. The very idea of a "blueprint" evokes images of factories and manufacturing, together with uncreative drones. In an environment that is 80% construction and 20% design, like manufacturing, it makes sense to view the blueprint as the plan that is predictive of the construction work to be done. "Heavyweight" processes have encouraged the idea of model as blueprint; the manufacturing analogy is drawn repeatedly in the Software Engineering Institute's Capability Maturity Model (CMM), for example. But we know software is a creative new-economy thing, not at all like old-fashioned manufacturing. To the contrary, software is known for its creative aspects, entailing more like 80% design and 20% construction. In this case, developers need to be adaptive rather than predictive in their relationship to any model, effectively ruling out the use of models as blueprints.

The third denotation for the word is the model as an executable.2 The model of the airplane can be transformed into the real, physical airplane. The transformation requires other inputs, in this case the metal plates, bolts, and screws that make up the body, yet the model is complete in every detail in the one aspect of the problem related to the shape-that-flies. When we build an executable UML model, we have described the behavior of our system just as surely as we had when we wrote a program in Java.

Under this interpretation of "model" as an executable, a program in a high-level language such as Java is a model too. The Java program can be transformed into the real thing (byte code). The builder of the model, the programmer in this case, need not know how a Java compiler works, nor what the compiler does to make a program run. Of course, the byte code produced by the compiler is itself a model that can be replaced by ones and zeroes, one layer of abstraction removed, and those ones and zeroes in turn define the desired behavior of the underlying hardware, yet one more layer of abstraction away.

Many of the principles of Extreme Programming (XP) and the Agile Alliance involve process and customer relationships and their management, not code. As such, the agile process principles for the construction of code apply just as well for the construction of executable models. For those XP principles that do specifically mention "code" or "software," executable UML is code.

Executable UML allows developers to model the underlying semantics of a subject matter without having to worry about the number of the processors, data-structure organization, the number of threads, and so forth. In other words, just as programming languages conferred independence from the hardware platform, executable UML confers independence from the software platform, which makes executable UML models portable across multiple development environments.

At system construction time, the executable UML compiler maps conceptual objects to threads and processors. The compiler's job is to maintain the desired sequencing specified in the application models, but it may to choose to distribute objects, further order their behaviors sequentially, even duplicate them redundantly, or split them apart, so long as the defined behavior is preserved.

A program in C++ is complete and executable, but that doesn't do us much good until it has been transformed into some language that can be directly interpreted. We therefore run the program through a series of transformations that preserve the semantic content of the program (otherwise there's an error in the compiler) but express it in a language more oriented to implementation.

The same happens when we build a complete executable model. When we transform a model, tools populate the metamodel for the modeling language at hand. To carry our language example above to extremes, we could use the text of a C++ program to populate the instances of a model of C++ with classes Class, ProtectedMember, StaticMemberFunction and so on. As a result of the next transformation, we would have a model of C, in which instances of StaticMemberFunction and ProtectedMember would both be cast as ordinary functions, although with different signatures.

Such transformations may be continued indefinitely until the final, lowest, most grungy metamodel of them all. The classes in an (assembly-language) metamodel could be Instruction, Registers, MemoryLocation, and so on. The instances in this metamodel contain all the information of all the "higher level" models, but at a low level of abstraction.

An executable UML model compiler weaves together several models, where each model specifies some aspect of a system at a high level of abstraction. The weaving produces a single model that is at a lower level of abstraction. The model compiler then compiles the single model, producing textual code such as C++, Java, assembly, and so forth, which is at a yet lower level of abstraction. A C++ or Java compiler, or an assembler, processes the textual code in turn. Ultimately, this process generates code that runs over some virtual machine, such as the Java VM, or that runs directly over the CPU.

  • + Share This
  • 🔖 Save To Your Account