Model Driven Architecture – Foundations and Applications

Enterprise business applications are critical to the smooth operation of modern businesses and need to quickly respond to changing business rules, processes and technologies. Also, the ever-increasing thrust on collaboration calls for these applications to smoothly integrate with each other. MDA enables an application to be specified in terms of platform independent models each addressing a concern of interest and then transforming them into a platform-specific implementation. Traditional organization of an enterprise, as a set of functionally distinct departments, results in a set of isolated applications providing point solutions each constructed for a specific purpose with context-specific built-in assumptions implicit in their specifications. These assumptions lead to conflicts or mismatches during integration calling for application integration to be addressed as an explicitly modeled concern. Typically, a business application needs to be specialized for the requirements of a specific enterprise. Product line architectures that organize systems into well-defined core and variable parts have been proposed to address this need. However, traditional code based development approaches lack suitable abstractions to support product lines. We propose a model driven architectural framework that enables a system to be specified in terms of composable units, along the required dimensions of variation, wherein the integration requirements are modeled explicitly. Component interface is augmented with data models, process models, constraints, assertions and pre/post-conditions. A set of properties that need to be satisfied for semantically correct integration are proposed along with a set of verification techniques. We propose a software factory that seamlessly addresses development and integration needs of enterprise product lines and describe our experience in building and using it.

Business corporations use frameworks and heterogeneous tools in the running of their systems. Most of these systems require the interaction between heterogeneous architectures, technologies and platforms. This integration is usually a complex task, which Model-Driven Architecture (MDA) approach to Model-Driven Software Development (MDSD) has promised to facilitate. In this paper we present a MDA-based methodology to platforms integration and show how it is successfully applied to a real business environment. In particular, the integration of three technological platforms (a framework based on Struts and J2EE, the transactional system CICS and the document manager FileNet) into a single development environment was carried out. Using this development environment, application code is 100% generated from UML-based models.

To our knowledge, no current software development methodology explicitly describes how to transit from the analysis model to the software architecture of the application. This paper presents a method to derive the software architecture of a system from its analysis model. To do this, we are going to use MDA. Both the analysis model and the architectural model are PIMs described with UML 2. The model type mapping designed consists of several rules (expressed using OCL and natural language) that, when applied to the analysis artifacts, generate the software architecture of the application. Specifically the rules act on elements of the UML 2 metamodel (metamodel mapping). We have developed a tool (using Smalltalk) that permits the automatic application of these rules to an analysis model defined in Rose^TM to generate the application architecture expressed in the architectural style C2.

We present a case study that utilizes UML modeling methodology for typical business applications. Such applications generally contain a GUI front-end for manipulating database tables and are object-relational systems that deal with both relational databases and object-oriented technology. To model such applications, we use UML Profiles and metamodels based on a three-tiered application architecture for the different stages of the development lifecycles. The benefits of the model-driven approach include the possible use of the models for maintenance processes such as incremental code generation, updating test cases, and documentation. These models also enable developers to validate the application’s flow by simulating its behavior through model execution.

In this paper we present a methodology supporting the definition of data models on basis of a limited set of well-known UML features, thereby allowing these models to be created and discussed by a large group of domain experts. A transformation is then defined from such a platform independent UML model to XML schema, which exceeds the configuration possibilities of comparable approaches like XMI. This enables the generic reproduction of a wide range of existing XML languages and hence supports reverse-engineering legacy schemas and DTDs into well-structured UML models. The overview of an actual implementation of the generic methodology finally demonstrates the practical applicability or our approach. The work described in this paper is part of the AUTOSAR development partnership, an international effort to standardize automotive software infrastructure. The resulting XML schema is used today as the official AUTOSAR XML data exchange format.

Experience reports show that MDD reduces time-to-market and increases productivity by means of platform independent business logic modelling and automation. Achieving these two concepts in the organisation is not a one step process. This paper explains the MDD Maturity Model developed to drive this task in a structured way. The MDD Maturity Model establishes five capability levels towards the progressive adoption of MDD within an organisation. Each level describes a coherent set of engineering, management and support practices involved in the MDD approach, and characterizes the MDD artefacts, called MDD elements, used in or resulted from those practices. The paper presents also the validation process that the model will undergo in two large organisations and two SMEs.

Organisations are always looking for better and faster ways of developing systems. One of the technologies that promise this is Model Driven Development (MDD), but there are still only a few organisations that have been capable of maximizing the benefits of MDD. The success of these few cases is based on the establishment of a clear system development process which encompasses both the activities that must be performed as well as the tools that need to be used within the organisation to adopt MDD. When an organisation considers adopting MDD, the first barrier it encounters is the lack of well-documented success stories which clearly state the process followed by these organisations. This paper presents a common repository of MDD processes/ practices which have been extracted from successful MDD adoption stories, in the form of the MDD Process Framework.

A core problem in Model Driven Engineering is model consistency achievement: all models must satisfy relationships constraining them. Active consistency techniques monitor and control models edition for preventing inconsistencies, e.g., using automatic errors correction. The main problem of these approaches is that strict enforcement of consistency narrows the modeler’s possibilities for exploring conflicting or tradeoff solutions; this is just what temporaries inconsistencies enable. In this article, we propose a hybrid approach capitalizing on active consistency characteristics while allowing the user to edit inconsistent models in a managed mode: at any moment we are able to propose a sequence of modelling operations that, when executed, make the model consistent. The solution consists in defining a set of automatons capturing a sufficient part of the model state space for managing any inconsistent situation. We illustrate this approach on a consistency relationship implied by the application of a security design pattern impacting both class and sequence diagrams of a UML2 model.

The Unified Modelling Language (UML) is intended to describe systems, but it is not clear what systems satisfy a given collection of UML diagrams. Stephen Mellor has described a small collection of diagrams which appear to be inconsistent, yet are “cool” according to UML. We describe an approach to defining semantics for UML diagrams using dynamic logic, and show that Mellor’s example is inconsistent, given a reasonable assumption. Our approach interprets all diagrams, static and dynamic, in a single semantic space. The modeller specifies how the meaning of a model is made up from the meanings of its diagrams, thus the “viewpoint” taken by each diagram is made explicit. This composition is achieved through formation of the dynamic logic formulae. It is therefore very flexible, and we propose it as a means for defining semantics for domain specific languages, and for specifying “bridges” or “weaving” model transformations used in aspect oriented modelling.

Model-Driven Development requires model management languages and tools for supporting model operations such as editing, consistency checking, and transformation. At the core of these model management techniques is a set of facilities for model navigation and modification. A subset of the Object Constraint Language can be used for some of these tasks, but it has limitations as a general-purpose language to be used in a variety of model management tasks. We present the metamodel independent Epsilon Object Language (EOL) which builds on OCL. EOL can be used both as a standalone generic model management language or as infrastructure on which task-specific languages can be built. We describe how it has been used to construct a selection of languages, such as model merging, comparison, and text generation languages.

A difficult challenge in the industrialisation of Model-Driven Development is managing different versions of models. Different versions may arise at any time during the development process, due to different individuals or teams working on different parts of the overall model. To manage these versions it is necessary to be able to identify differences and reconcile these differences in a single, integrated model. We describe the use of model merging technology for managing different versions of a model in an industrial software development process. The use of automated model merging technology is contrasted with an alternative, semi-automated approach. The contributions of model merging to helping to solve this problem are outlined.

Model transformation is a key technology of model driven development approaches. A lot of research therefore is being carried out to understand the nature of model transformations and find out desirable characteristics of transformation languages. In recent years, several transformation languages have been proposed.

We present the RubyTL transformation language which has been designed as an extensible language–a set of core features along with an extension mechanism. RubyTL provides a framework for experimenting with features of hybrid transformation languages. In addition, RubyTL has been created as a domain specific language embedded in the Ruby programming language. In this paper we show the core features of the language through a simple example and explain how the language can be extended to provide more features.

In the model driven software development process, software is built by constructing one or more models and transforming these into other models. In turn these output models may be transformed into another set of models until finally the output consists of program code that can be executed. Ultimately, software is developed by triggering an intricate network of transformation executions.

An open issue in this process is how to combine different transformation tools in a flexible and reliable manner in order to produce the required output. This paper presents a model transformation environment in which new transformation tools can be plugged in and used together with other available transformation tools. We describe how transformations can be composed. Furthermore, in the cause of answering the question where and how transfor-mations can be successfully applied, we created a language-based taxonomy of model transformation applications.

Context-awareness is a very important feature for pervasive services to enhance their flexibility and adaptability to changing conditions and dynamic environments. Using ontologies to model context information and to reason about context at a semantic level has attracted a lot of interest in the research community. However, most of the proposed solutions are ad hoc or proprietary. Therefore, employing standard approaches to formulate the development process becomes of importance. In this paper we examine how OMG’s Model Driven Architecture (MDA) can be applied to tackle the issues of context modelling and Context-Aware Application (CAA) modelling and development. A Context Ontology Model (COM) is presented to model context information at two levels: upper-level and extended specific level. A Model Driven Integration Architecture (MDIA) is then proposed to integrate rigorous model specifications and generate CAA implementations either semi-automatically or automatically.

Building service-based architectures has become a major area of interest since the advent of Web services. Modelling these architectures is a central activity. Model-driven architecture is a recent approach to developing software systems based on the idea of making models the central artifacts for design representation, analysis, and code generation. We propose an ontology-based composition and transformation approach for model-driven service architecting. Ontology technology as a logic-based knowledge representation and reasoning framework can provide answers to the needs of sharable and reusable models and descriptions needed for service engineering. Based on UML-style visual modelling of service architectures and their mapping into an ontology representation, our approach enables ontology-based semantic modelling based on representation, analysis, and code-generation techniques for Web services.

In this paper we report on a feasibility study in reengineering legacy systems towards a model-driven architecture (MDA). Steps in our approach consist of (1) parsing the source code of the legacy system according to a grammar; (2) mapping the abstract syntax trees thus obtained to a grammar model that is defined in the Meta-Object Facility (MOF); (3) using model to model (M2M) transformations to turn the grammar model into a generic meta-model, called GenericAST, in which information about software systems can be stored in a language-independent way; (4) mapping the GenericAST models, again using M2M transformations, to UML models that can be either used for code generation or for documentation purposes. The steps have been implemented in a prototype model harvesting tool that is based on ArcStyler, the MDA environment provided by Interactive Objects. Our paper presents this approach, and reports on our experiences in applying the method to a 178 KLOC production system from the insurance domain written in PL/SQL.

Databases are one of the most important components of information systems, since they keep all the information of organizations. Although new standards in databases have appeared in the last years, most databases are still based on SQL-92, and are thus true legacy systems. Most of the services offered by information systems are based on the information stored in their databases. In order to allow interoperability, current trends advise exposing some of these services to the Web, making them available for other users and also for the information system itself. Since dealing with old databases and their associated software is difficult, a methodology to discover services from SQL-92 databases and to offer them via Web Services is proposed. This methodology is based on the MDA approach and implements a reengineering process, which starts from an SQL-92 database and obtains a set of services that can be exposed as Web Services.

General-purpose modeling languages are inadequate to model and visualize business processes precisely. An enterprise has its own vocabulary for modeling processes and its specific tasks may have attached data that define the tasks precisely. We propose using Domain Specific Modeling (DSM) languages to model business processes, such that an enterprise can define its own DSM language(s) capturing its vocabulary and data requirement. We suggest using UML profiles and UML activity diagrams as the semantic base for these DSM languages and present tools that are able to create a DSM language and tool support for a given domain. One tool, called ADSpecializer, can generate a UML profile and its tool support of a given application domain. The other tool, ADModeler, is used to create UML activity diagrams within such a domain-specific UML profile. The two tools enable an enterprise to efficiently define and utilize their own DSM language.

The growing interest in the MDA (Model-Driven Architecture) and MDD (Model-Driven Development) approaches has largely increased the number of tools and methods including code-generation capabilities. Given a platform-independent model (PIM) of an application, these tools generate (part of) the application code either by defining first a platform-specific model or by executing a direct PIM to code transformation. However, current tools present several limitations regarding code generation of the integrity constraints defined in the PIMs. This paper compares these tools and shows that they lack expressiveness in the kind of constraints they can handle or efficiency in the code generated to verify them. Based on this evaluation, the features of an ideal code-generation method for integrity constraints are established. We believe such a method is required to extend MDA adoption in the development of industrial projects, where constraints play a key role.

Higher-level modelling is considered to be the answer to many of the problems computer science is faced with. In order to do modelling, it is necessary to use proper tools. This article is about modelling tools and how they can be generated automatically out of (modelling) language descriptions. Language descriptions in turn are given in meta-models. In this article, we define a terminology for aspects of meta-models and check how they are supported by existing meta-modelling tools. In particular we look at semantic aspects of the meta-models.

From a software engineering point of view, the agent paradigm has shown its potential for modelling in different domains. However, moving from agent models to implementation is not fully addressed by most agent-oriented methodologies in a systematic way. In most cases, they focus on the agent concept at the analysis level or look for visual or formal representations of elements present in an already implemented agent framework. Here we show that model driven development with agent-based models can facilitate the implementation of methods and tools for the development of multi-agent systems. This is illustrated with the INGENIAS methodology and its tools, the INGENIAS Development Kit (IDK), which are founded on the definition of the INGENIAS meta-models for multi-agent systems, and implement most of the facilities that a model driven development approach requires.

In object-oriented software development, UML artefacts are used to illustrate and define the structure and the behaviour of the software system, while the semantics is usually described in a formal or informal specification language. The specification often consists of sets of constraints defined over the software components. When implementing the model, the specification is taken into consideration by the implementor. Since a significant proportion of the implementation consists of human-generated code, errors may be introduced in the implementation model. To detect these errors, the specified constraints need to be checked in the implementation. In this paper, we present Limes, an imperative constraint implementation language, which adopts aspect-oriented programming to describe constraint checking in a non-invasive way. Limes can be used at the design level, and can add constraint checking to the implementation.

In the Model-Driven Architecture initiative, software artefacts are represented by means of models that can be manipulated. Such manipulations can be performed by means of transformations and queries. The standard Query/Views/Transformations and the standard language OCL are becoming suitable languages for these purposes. This paper presents an algebraic specification of the operational semantics of part of the OCL 2.0 standard, focusing on queries. This algebraic specification of OCL can be used within the Eclipse Modeling Framework to represent models in an algebraic setting and to perform queries or transformations over software artefacts that can be represented as models: model instances, models, metamodels, etc. In addition, a prototype for executing such OCL queries and invariants over EMF models is presented. This prototype provides a compiler of the OCL standard language that targets an algebraic specification of OCL, which runs on the term rewriting system Maude.

MDA generally involves applying multiple model transformations. These transformations need to be applied in a particular configuration, depending on the targeted platform. Several techniques exist to manage the configuration of various software elements or components. These techniques focus on the composition rules of the various elements. A well-known application area of such techniques are Software Product Lines, in which the various features that make up a software product need to be configured. In this paper, we will investigate how several of these techniques can be applied to manage the configuration of model transformations in an MDA context.

There is little agreement on terminology in model composition, and even less on key characteristics of a model composition solution. We present three composition frameworks: the Atlas Model Weaver, the Epsilon Merging Language, and the Glue Generator Tool, and from them derive a core set of common definitions. We use this to outline the key requirements of a model composition solution, in terms of language and tool support.

The crucial point in Model Driven Architecture (MDA) is that software and system development are based on abstract models that are successively transformed into more specific models, ideally resulting in the desired system. To this end, developers must be enabled to model different aspects like structure, behavior, consistency constraints of the system. This results in a variety of related models, which in turn need tool support on the metalevel. However, there is a lack of tools offering uniform support for metamodel definition, analysis, transformation, and integration. In this paper we present the metamodeling framework MOFLON that addresses these issues by bringing together the latest OMG standards with graph transformations and their formal semantics. MOFLON provides a combination of visual and textual notations and offers powerful modularization concepts. Using MOFLON, developers can generate code for specific tools needed to perform the desired modeling tasks.

In MDE, model transformations should be efficiently tested so that it may be used and reused safely. Mutation analysis is an efficient technique to evaluate the quality of test data, and has been extensively studied both for procedural and object-oriented languages. In this paper, we study how it can be adapted to model oriented programming. Since no model transformation language has been widely accepted today, we propose generic fault models that are related to the model transformation process. First, we identify abstract operations that constitute this process: model navigation, model’s elements filtering, output model creation and input model modification. Then, we propose a set of specific mutation operators which are directly inspired from these operations. We believe that these operators are meaningful since a large part of the errors in a transformation are due to the manipulation of complex models regardless of the concrete implementation language.