Information Technology Reference
In-Depth Information
One example is the UML4ODP plug-in for MagicDraw. These domain-specific
tools allow users to work with the ODP concepts and mechanisms as first class
entities in their editors, and provide common skeletons and templates for the
specifications.
However, editing with a set of UML profiles may not be enough when
building large system specifications. There is also the need to check that the
structure and architecture of these specifications is correct. One of the benefits
of using a reference model such as the RM-ODP is that it allows structuring
the specifications according to a fully tested standard architecture. The fact
that the structuring rules of ODP viewpoint languages are explicitly defined
in the standard has enabled the development of tools that allow validation of
the models, checking that they comply with the ODP reference architecture.
This is already possible with some of the plug-ins mentioned previously, which
are able to detect missing parts of the specification, architectural problems,
conflicting elements or violation of the structuring rules.
Another key role for tools in this context can be seen in the validation
of the individual viewpoint specifications. We have mentioned that there
are notations for the viewpoints that allow their formal analysis and even
simulation. The question is how to connect the UML4ODP specifications
with these notations so as to be able to make use of their toolkits. This is
where model-driven techniques really come into play.
15.3 Model-Driven Approaches
There has been a great deal of emphasis in recent years on the develop-
ment of model-driven techniques for system design and development. This
movement is marked by a change of emphasis from a situation where models
were used primarily to capture requirements and set the scene for a creative
coding process to a situation where the models are the prime focus of the de-
sign and the source representation for design information, from which a largely
mechanical implementation process derives its steering information. The as-
sumption is then that the models are the place to go to answer any questions
about the system. Any modifications are carried out as changes to the models
followed by an incremental reworking of the implementation process. With
strong enough tools, this reworking can be cheap and quick to carry out.
We are all familiar with such almost total reliance on tools in the support of
high-level languages. The overwhelming proportion of program development
is now carried out in languages like Java, and hardly anyone gives a second
thought to the processes of compilation from high-level language to object
code, or JIT compilation of object code to machine code, that underlie the
execution of such code. Promoting this to start at the model level is not
entirely straightforward because the models are more abstract and one single
