Model Driven Architecture – Foundations and Applications

Before a development project based on MDA can start, an important effort has to be done in order to select and adapt existing MDA technology to the considered application domain. This article presents our experience in applying MDA technology to the voice application domain. It describes the iterative approach followed and discusses issues and needs raised by the experience in the area of building MDA tool chains.

The paper discusses some practical examples of how Model Driven Architecture (MDA) technology is being applied to some vital issues in the development of avionics systems. A study primarily aimed at addressing the issue of Software Method and Tool obsolescence was conducted by a number of BAE Systems’ sites and York University. It investigated model transformat-ion from legacy Teamwork models to UML models. It then went on to investigate the re-modelling of a component of a legacy avionics system in executable UML, the development of an Ada code generator, and the integration of the resulting auto-generated code into the embedded system without any degradation of functionality and performance. Another Anglo-French study was conducted to investigate software development methods and tools for the challenging Integrated Modular Avionics architecture. Both of these studies contained themes regarding the application of meta-modelling and model transformation.

Domain Driven Development (DDD) is one key to conquering the complexity of large-scale software systems. The use of domain-specific models raises the level of abstraction in programming, and helps modularizing and automating the development process. However, in pilot projects using MDx approaches we have experienced the need for more tool support on model level, in particular for monitoring, debugging, and testing. In this paper, we investigate monitoring and feedback mechanisms that make models reflecting the current state of the running system. Additionally, we describe a prototypical implementation, which is a starting point for further work on enabling debugging and testing on model level.

The model-driven software development for hard real-time systems promotes the usage of the platform independent model as major design artifact. It is used to develop the software logic at a high level of abstraction and enables analysis like for example model checking of critical model properties. Ideally, starting with the platform independent model, the platform specific model serves only as an intermediate artifact which is derived automatically, and will finally result in a set of threads whose implementations guarantee the behavior, specified in the platform independent model. However, the current MDA approaches and tools for hard real-time software do not provide this ideal: While some of the MDA approaches could in principle support this vision, most approaches simply do not support an appropriate specification of time constraints in the platform independent model which have to be respected in the platform specific model or in the code. This is also true for UML models and UML State Machines in particular. Our approach overcomes those UML specific limitations by firstly proposing a syntactic extension and semantic definition of UML State Machines which provides enough details to synthesize an appropriate platform specific model that can be mapped to code for hard real-time systems automatically. Secondly, a new partitioning algorithm is outlined, which calculates an appropriate mapping onto a platform specific model by means of real-time threads with their scheduling parameters which can be straight forward transformed to code for the hard real-time system.

The popular model-driven development (MDD) methodology strongly promotes a model-based approach to modular system development, which often implies as an integral part automatic transformation of UML design components into executable forms. When using MDD for verifying performance-related system specifications, UML designs annotated with these specifications in some profile language need to be transformed to stochastic (Markovian) models or timed simulation models. However, most of the previous efforts have focused on transformations of (variants of) UML state machine models and/or transformations to stochastic Petri net models, which lead to two problems: Relying (solely) on state machine models often restricts design flexibility (designers instead prefer choosing diagrams on a case-by-case basis), and graph-oriented Petri net models complicate the modular transformations of UML models.

To resolve these problems, we propose stochastic performance analysis of a UML design defined in different sorts of diagrams, including not only state machines but also activity diagrams with temporal annotation in UML-SPT, which are transformed into stochastic process algebraic forms. To our knowledge, this is the first attempt to define stochastic process algebraic semantics for the UML AD with UML-SPT annotations. Unlike the related efforts, ours will facilitate verification in early development stages, in which consultants and architects can benefit from modeling in a natural manner and modular component-based development, thanks to the inherent compositionality of process algebra. Further, to guarantee the validity of the transformation, we have proved the equivalence of our semantics with the stochastic Petri net semantics of UML AD.

We have developed a prototype implementation of this performance analysis mechanism, and shown that realistic design examples, defined in different sorts of UML diagrams, can successfully be transformed into those that provide various performance metrics.

As the Model Driven Development (MDD) and Product Line Engineering (PLE) appear as major trends for reducing software development complexity and costs, an important missing stone becomes more visible: there is no standard and reusable assets for packaging the know-how and artifacts required when applied these approaches. To overcome this limit, we introduce in this paper the notion of MDA Component, i.e., a packaging unit for encapsulating business know-how and required resources in order to support specific operations on a certain kind of model. The aim of this work is to provide a standard way for representing this know-how packaging units. This is done by introducing a two-layer MOF-compliant metamodel. Whilst the first layer focuses on the definition of the structure and contents of the MDA Component, the second layer introduces a language independent way for describing its behavior. For a full specification, both layers can be merged using the UML2.0 package merge facility.

Components should provide maximum flexibility to increase their reusability in different applications and to work under changing environment conditions as part of a single application. Thus, adaptation and reconfiguration mechanisms of single components and component assemblies play a crucial role in achieving this goal. In this paper we present a model of Adaptable Components that allows modelling of adaptation and reconfiguration operations taking place at development, deployment or runtime. The concept of composite components is utilized to encapsulate adaptation operators and to map component parameters to different predefined internal configurations of subcomponents. The component model is not tied to a particular component platform. Instead, it can be mapped to existing component platforms like EJB using an MDA approach. Different Platform-Specific Models for the same target component platform enable tailored flexibility for particular component deployments. For example, a model can support or not support runtime reconfiguration. Extensions to UML diagrams are introduced to graphically model reconfiguration operations.

Modelling is recognised as an essential activity in the architectural design of software systems. Model-driven architecture (MDA) is a framework implementing this idea. Ontologies are knowledge representation frameworks that are ideally suited to support modelling in this endeavour. We propose here a layered ontological framework that addresses domain modelling, architectural modelling, and interoperability aspects in the development of service-based software systems. We illustrate the benefits of ontological modelling and reasoning for service-oriented software architectures within the context of the Web Services.

Model-driven development (MDD) is an important technology since it helps to reduce the cost of software development and maintenance. Furthermore, it may increase the quality of resulting systems. However, it is naive to try to generate complete complex systems out of a single model. This paper presents hot spot domains of business information systems where MDD is particularly applicable. For those domains, proven techniques for combining MDD with software architecture principles are presented. This distils the experience with MDD at sd&m for more than fifteen years.

Model-Integrated Computing (MIC) is an approach to Model-Driven Architecture (MDA), which has been developed primarily for embedded systems. MIC places strong emphasis on the use of domain-specific modeling languages (DSML-s) and model transformations. A metamodeling process facilitated by the Generic Modeling Environment (GME) tool suite enables the rapid and inexpensive development of DSML-s. However, the specification of semantics for DSML-s is still a hard problem. In order to simplify the DSML semantics, this paper discusses semantic anchoring, which is based on the transformational specification of semantics. Using a mathematical model, Abstract State Machine (ASM), as a common semantic framework, we have developed formal operational semantics for a set of basic models of computations, called semantic units. Semantic anchoring of DSML-s means the specification of model transformations between DSML-s (or aspects of complex DSML-s) and selected semantic units. The paper describes the semantic anchoring process using the meta-programmable MIC tool suite.

Designing Information Systems (IS) is a complex task that involves numerous aspects, being functional or not. A way to achieve this is to consider models as generic pieces of design in order to build a complete IS. Model composition provides a way to combine models and model parameterization allows the reuse of models in multiple contexts. In this paper, we focus on the use of parameterized models in model driven engineering processes. We outline the needs to compose parameterized models and apply them to a system according to alternative and coherent ordering rules. Such building processes raise open issues: Is the result influenced by the order of applications? Can we compose independent parameterized models? Is it possible to define composition chains and find equivalent ones that express the same resulting model? These requirements are formalized through an apply operator. This operator guarantees properties which can help in the formulation of model driven system construction methodologies. Finally, we briefly describe a modelling tool that supports processes based on this operator.

The application of MDA to Web services has recently received considerable attention. Similar to UML diagrams, Web services are specialised languages each one targeting a specific aspect and functionality of the system. By using multiple languages, it is possible to specify complete integrated models of the system, having structure, behaviour, communication and coordination mechanisms. To benefit from MDA, Web service languages have to be represented as UML metamodels. In order to provide an overall view of the design and inter-operations of the system with models, it is crucial to integrate their UML metamodels. In this paper, we shall conduct a comparative study of the metamodel integration in Web services and UML. Drawing on the lesson learnt from the integration of Web services, a method of integration of UML metamodels will be presented, which facilitates model transformations and supports interoperability, inter-navigability and consistency across the integrated domains.

This article presents a control flow analysis methodology based on UML 2.0 sequence diagrams (SD). In contrast to the conventional code-based control flow analysis techniques, this technique can be used earlier in software development life cycle, when the UML design model of a system becomes available. Among many applications, this technique can be used in SD-based test techniques, model comprehension and model execution in the context of MDA. Based on the well-defined UML 2.0 activity diagrams, we propose an extended activity diagram metamodel, referred to as Concurrent Control Flow Graph (CCFG), to support control flow analysis of UML 2.0 sequence diagrams. Our strategy in this article is to define an OCL-based mapping in a formal and verifiable form as consistency rules between a SD and a CCFG, so as to ensure the completeness of the rules and the CCFG metamodel with respect to our control flow analysis purpose and enable their verification. Completeness here means if the CCFG metamodel has all classes and associations needed, and the rules are adequate with respect to our purpose. Furthermore, we define Concurrent Control Flow Paths, which are a generalization of the conventional Control Flow Path concept. The control flow analysis technique is applied to an example SD to demonstrate the feasibility of the approach.

Domain-specific languages are of increasing importance in software engineering. Little attention has been paid to the systematic production of domain-specific contract languages (DSCLs). In this paper, we present a metamodel-based approach for designing DSCLs. An extensible metamodel for software contracts is presented, and a process for building DSCLs is sketched. Finally, an example of building a DSCL is demonstrated, using the metamodel and process.

Language-centric methodologies, triggered by the success of Domain Specific Languages, rely on precise specifications of modeling languages. While the definition of the abstract syntax is standardized by the 4-layer metamodel architecture of the OMG, most language specifications are held informally for the description of the semantics and the (graphical) concrete syntax. This paper is tackling the problem of specifying the concrete syntax of a language in a formal and non-ambiguous way. We propose to define the concrete syntax by an extension of the already existing metamodel of the abstract syntax, which describes the concepts of the language, with a second layer describing the graphical representation of concepts by visual elements. In addition, an intermediate layer defines how elements of both layers are related to each other. Unlike similar approaches that became the basis of some CASE tools, the intermediate layer is not a pure mapping from abstract to concrete syntax but connects both layers in a flexible, declarative way. We illustrate our approach with a simplified form of statecharts.

Efficient tool support for transformations is a key requirement for the industrialisation of MDA. While there is substantial and growing support for unidirectional transformations (e.g., from PIM-to-PSM), for bidirectional transformations there is little. This paper presents tool support for bidirectional transformations, in the form of a language, called XRound, for specifying reversible templates. The language supports round-trip transformations between UML models and predicate logic. Its supporting tool also implements model unification, so that new information encoded in logic can be seamlessly integrated with information encoded in the model.

A highly significant benefit of MDA is that it raises the level of abstraction at which the soft-ware developer is able to work. However, the languages available to the developer have not seen much change in the last decade. Modeling languages offer high level concepts, but the pre-dominant modeling language (UML) offers too little expressive power to be able to specify a system completely. Meanwhile, the level of abstraction of most programming language con-cepts is the same as 10 to 15 years ago. Although transformation tools may to some extent bridge the gap between modeling and programming languages, in practice the developer still needs to do both modeling and programming. This means switching between the two levels of abstractions, which is difficult for most people. We argue that a general purpose, high level, software language is necessary to get MDA adopted. This language will enable any developer to focus on the problem at hand while the supporting tools – transformation tools or generators- take care of the nitty gritty details. This paper introduces an early version of such a language, which brings together a number of powerful concepts from various sources: UML, OCL, design patterns, existing programming languages, and eventually aspect-oriented languages.

The objective of this work is to assess the qualities of the MOFScript language, which has recently been submitted to the OMG as a proposed model to text transformation language. This is done by identifying requirements for this type of language and evaluating the MOFScript language with regard to these. The language is presented along with a tool implementation and compared with the alternative languages submitted to the OMG Model to Text RFP.

Queries on software artifacts play an important role in novel software development approaches, such as Aspect-Oriented Software Development and OMG’s Model Driven Architecture. Keeping them separate from the modifications operating on them has proven to be beneficial with respect to their comprehensibility and their reusability. In this paper we describe what relationships can exist between such stand-alone queries. These relationships allow the combination of existing queries to form new ones, enabling developers to come up with abstractions for common selection patterns.

As the number of available Web services increases there is a growing demand to realize complex business processes by combining and reusing available Web services. The reuse and combination of services results in a composition of Web services that may also involve services provided in the Internet. With semantically described Web services, an automated matchmaking of capabilities can help identify suitable services. To address the need for semantically defined Web services, OWL-S and WSML have been proposed as competing semantic Web service languages.

Both proposals are quite low-level and hard to use even for experienced Web service developers. We propose a UML profile for semantic Web services that enables the use of high-level graphical models as an integration platform for semantic Web services. The UML profile provides flexibility as it supports multiple semantic Web service languages. Transformations of both ways between OWL-S and UML are implemented to show that the UML profile is expressive enough to support one of the leading semantic Web service languages.

Models and model transformations are the core concepts of OMG’s MDA ^TM approach. Within this approach, most models are derived from the MOF and have a graph-based nature. In contrast, most of the current model transformations are specified textually. To enable a graphical specification of model transformation rules, this paper proposes to use triple graph grammars as declarative specification formalism. These triple graph grammars can be specified within the FUJABA tool and we argue that these rules can be more easily specified and they become more understandable and maintainable. To show the practicability of our approach, we present how to generate Tefkat rules from triple graph grammar rules, which helps to integrate triple graph grammars with a state of a art model transformation tool and shows the expressiveness of the concept.

In this last decade component technology has known a fast expansion, initially with EJB (Enterprise JavaBeans), and more recently with .NET. Many companies would probably not hesitate to embrace the new technological wave of .NET components if they could recover (part of) their investment in EJB. As it is more than probable that existing EJB applications do not have models independent of the technological platform (PIM), we propose a horizontal migration path between these two technologies by the definition of a transformation which converts a model specific to EJB (PSM) into a model specific to the .Net components. Since metamodels of these two technologies are essential to the definition of our transformation, we use the EJB metamodel adopted by the OMG and, for the .NET components, we propose a metamodel of our vintage. The transformation is written in a well-defined language derived from a submission in response to the RFP issued by the OMG to standardize the transformation language QVT. The feasibility of the idea is illustrated with an example.

In a MDA process, software artifacts are refined from the problem space (requirements) to the solution space (application). A model refinement involves the application of operators that perform tasks over models such as integrations and transformations, among others. We are working on a model management framework, called MOMENT (MOdel manageMENT), where model operators are defined independently of any metamodel in order to increase their reusability. This approach also increases the level of abstraction of solutions of this kind by working on models as first-class citizens, instead of working on the internal representation of a model at a programming level. In this context, traceability constitutes the mechanism to follow the transformations carried out over a model through several refinement steps. In this paper, we focus on the generic traceability support that the MOMENT framework provides. These capabilities allow the definition of generic complex operators that permit solving specific problems such as change propagation.

A software product line comprises a set of products implementing different configurations of features. The set of valid feature configurations within a product line can be described by a feature model. In some practical situations, a feature configuration needs to be derived in stages by creating a series of successive specializations of the initial feature model. In this paper, we consider the scenario where changes to the feature model due to, for example, the evolution of the product line, need to be propagated to its existing specializations and configurations. After discussing general dimensions of model synchronization, a solution to synchronizing cardinality-based feature models and their specializations and configurations is presented.