Model Driven Architecture - Foundations and Applications

MDA is often promoted to enable the portability of applications across platforms, but what of the development of platforms themselves? Today’s consumer electronics products, such as TVs and mobile phones are based on complex integrated circuits to support their many functions. Cost and power consumption is crucial and semiconductor suppliers have to deliver substantial amounts of software to deliver the best performance from their hardware designs. This low-level software might be exposed to customers as device drivers for the operating system of their choice, and their development gives a different perspective on "platform specific models". Given the sensitivity of this software to changes in both customer requirements and their overall software architecture, and to changes in the underlying hardware, software development and maintenance effort becomes an increasing proportion of the overall engineering effort. The presentation will describe the software development challenges faced by a semiconductor supplier and some of our experiments in meeting these challenges with MDA. It will reveal the technical limitations encountered and the greater problems of deploying unfamiliar technology across large development teams. This guides us in the hunt for the "sweet spot", where MDA delivers benefits with an acceptable learning curve and project risk.

In this paper we compare three model transformation languages: 1) Concrete syntax-based graph transformation (CGT) which is our emerging model transformation language, 2) Attributed Graph Grammar (AGG) representing traditional graph transformation, and 3) Atlas Transformation Language (ATL) representing model transformation. Our case study is a fairly complicated refactoring of UML activity models. The case study shows that CGT rules are more concise and requires considerably less effort from the modeler, than with AGG and ATL. With AGG and ATL, the transformation modeler needs access to and knowledge of the metamodel and the representation in the abstract syntax. In CGT rules on the other hand, the transformation modeler can concentrate on the familiar concrete syntax of the source and target languages.

The level of maturity that has been reached by model transformation technologies is proved by the growing literature on transformation libraries that address an increasingly wide spectrum of applications.

With the success of the modeling and transformation paradigm, the need arises to address more complex applications that require a direct manipulation of model transformations.

The uniformity and flexibility of the model-driven paradigm allows this class of applications to make use of the same transformation infrastructure. This is possible because transformations can be translated into transformation models and given as objects to a different class of model transformations, called Higher-Order Transformations (HOT).

This paper provides an introduction to HOTs and a survey of the several application cases where their use is relevant. A number of possible future applications of HOTs is also proposed.

Technological and business changes influence the evolution of software systems. When this happens, the software artifacts may need to be adapted to the changes. This need is rapidly increasing in systems built using the Model-Driven Engineering (MDE) paradigm. An MDE system basically consists of metamodels, terminal models, and transformations. The evolution of a metamodel may render its related terminal models and transformations invalid. This paper proposes a three-step solution that automatically adapts terminal models to their evolving metamodels. The first step computes the equivalences and (simple and complex) changes between a given metamodel, and a former version of the same metamodel. The second step translates the equivalences and differences into an adaptation transformation. This transformation can then be executed in a third step to adapt to the new version any terminal model conforming to the former version. We validate our ideas by implementing a prototype based on the AtlanMod Model Management Architecture (AMMA) platform. We present the accuracy and performance that the prototype delivers on two concrete examples: a Petri Net metamodel from the research literature, and the Netbeans Java metamodel.

Model Driven Software Development (MDSD) has matured over the last few years and is now becoming an established technology. Models are used in various contexts, where the possibility to perform different kinds of analyses based on the modelled applications is one of these potentials. In different use cases during these analyses it is necessary to detect patterns within large models. A general analysis technique that deals with lots of data is pattern mining. Different algorithms for different purposes have been developed over time. However, current approaches were not designed to operate on models. With employing QVT for matching and transforming patterns we present an approach that deals with this problem. Furthermore, we present an idea to use our pattern mining approach to estimate the maintainability of modelled artifacts.

Guidelines and consistency rules of UML are used to control the degrees of freedom provided by the language to prevent faults. Guidelines are used in specific domains (e.g., avionics) to recommend the proper use of technologies. Consistency rules are used to deal with inconsistencies in models. However, guidelines and consistency rules use informal restrictions on the uses of languages, which makes checking difficult. In this paper, we consider these problems from a language-theoretic view. We propose the formalism of C-Systems, short for “formal language control systems”. A C-System consists of a controlled grammar and a controlling grammar. Guidelines and consistency rules are formalized as controlling grammars that control the uses of UML, i.e. the derivations using the grammar of UML. This approach can be implemented as a parser, which can automatically verify the rules on a UML user model in XMI format. A comparison to related work shows our contribution: a generic top-down and syntax-based approach that checks language level constraints at compile-time.

Model-Driven Engineering techniques can be used both to create new software and to modernize existing software systems. Model-Driven Software Modernization requires a first step for the extraction of models. Most modernization scenarios involve dealing with the GPL source code of the existing system. Techniques and tools providing efficient means to extract models from source code are therefore needed.

In this paper, we analyze the difficulties encountered when using the existing approaches and we propose a language, called Gra2MoL, which is especially tailored to address the problem of model extraction. This provides a powerful query language for concrete syntax trees, and mappings between source grammar elements and target metamodel elements are expressed by rules similar to those found in model transformation languages. Moreover, the approach also allows reusing existing grammars.

Using model-based approaches for designing embedded systems helps abstract away unnecessary details in a manner that increases the potential for easy validation and verification, and facilitates reuse and evolution. A common practice is to use UML as the base language, possibly specialized by the so-called profiles. Despite the ever increasing number of profiles being built in many domains, there is still insufficient focus on discussing the issue of combining multiple profiles. Indeed, a single profile may not be adequate to cover all aspects required in the multidisciplinary domain of embedded systems. In this paper, we assess possible strategies for combining the SysML and MARTE profiles in a common modelling framework, while avoiding specification conflicts. We show that, despite some semantic and syntactical overlapping, the two are highly complementary for specifying embedded systems at different abstraction levels. We conclude, however, that a convergence agenda is highly desirable to align some key language features.

Textual Syntax (TS) as a form of model representation has made its way to the Model-Driven Software Development community and is considered a viable alternative to graphical representations. To support the design and implementation of text editing facilities many concrete syntax and model mapping tools have emerged. Despite the maturity of these tools, users still spend considerable effort to specify syntaxes and generate editors even for simple metamodels. To reduce this effort, we propose to refine a specification that is automatically derived from a given metamodel. We argue that defaults in a customisable setting enable developers to quickly realise text-based editors for models. In particular in settings where metamodels evolve, such a procedure is beneficial. To evaluate this idea we present EMFText [1], an EMF/Eclipse integrated tool for agile Textual Syntax (TS) development. We show how default syntax can easily be tailored and refined to obtain a custom text editor for EMF models and demonstrate our approach by two examples.

The size and the number of models is drastically increasing, preventing organizations from fully exploiting Model Driven Engineering benefits. Regarding this problem of scalability, some approaches claim to provide mechanisms that are adapted to numerous and huge models. The problem is that those approaches cannot be validated as it is not possible to obtain numerous and huge models and then to stress test them.

In this paper, we face this problem by proposing a uniform generator of huge models. Our approach is based on the Boltzmann method, whose two main advantages are its linear complexity which makes it possible to generate huge models, and its uniformity, which guarantees that the generation has no bias.

Model comparison is an essential prerequisite for a number of model management tasks in Model Driven Engineering, such as model differencing and versioning, model and aspect merging and model transformation testing. In this paper we present the Epsilon Comparison Language (ECL), a hybrid rule-based language, built atop the Epsilon platform, which enables developers to implement comparison algorithms at a high level of abstraction and execute them in order to identify matches between elements belonging to models of diverse metamodels and modelling technologies.

Version management of models is common for structural diagrams such as class diagrams but still challenging for behavioral models such as process models. For process models, conflicts of change operations are difficult to resolve because often dependencies to other change operations exist. As a consequence, conflicts and dependencies between change operations must be computed and shown to the user who can then take them into account while creating a consolidated version. In this paper, we introduce the concepts of dependencies and conflicts of change operations for process models and provide a method how to compute them. We then discuss different possibilities for resolving conflicts. Using our approach it is possible to enable version management of process models with minimal manual intervention of the user.

Traceability is demanded within mature development processes and offers a wide range of advantages. Nevertheless, there are deterrents to establishing traceability: it can be painstaking to achieve initially and then subject to almost instantaneous decay. To be effective, this is clearly an investment that should be retained. We therefore focus on reducing the manual effort incurred in performing traceability maintenance tasks. We propose an approach to recognize those changes to structural UML models that impact existing traceability relations and, based upon this knowledge, we provide a mix of automated and semi-automated strategies to update these relations. This paper provides technical details on the update process; it builds upon a previous publication that details how triggers for these updates can be recognized in an automated manner. The overall approach is supported by a prototype tool and empirical results on the effectiveness of tool-supported traceability maintenance are provided.

The need for a design language that is rigorous but accessible and intuitive is often at odds with the formal and mathematical nature of languages used for analysis. UML and Petri Nets are a good example of this dichotomy. UML is a widely accepted modelling language capable of modelling the structural and behavioural aspects of a system. However UML lacks the mathematical foundation that is required for rigorous analysis. Petri Nets on the other hand have a strong mathematical base that is well suited for analysis of a system but lacks the appeal and ease-of-use of UML. Design in UML languages such as Sequence Diagrams and analysis in Petri Nets require on one hand some expertise in potentially two incompatible systems and their tools, and on the other a seamless transition from one system to the other. One way of addressing this impediment is to focus the software development mainly on the design language system and to facilitate the transition to the formal analysis by means of a combination of automation and tool support. The aim of this paper is to present a transformation system, which takes UML Sequence Diagrams augmented with time constraints and generates semantically equivalent Petri Nets that preserve the timing requirements. A case study on a small network is used in order to illustrate the proposed approach and in particular the design, the transformation and the analysis processes.

The aim of UML Actions is to allow detailed and platform independent modeling of object-oriented behavior. However, behavior modeling with UML actions is still not adopted due to three main reasons. First, UML defines only the abstract syntax of the actions and no concrete syntax. Second, users have to work directly with the very complex meta-model of UML actions. Third, all existing tools do not provide appropriate support for creating and working with action-based behavior models. In this paper, we propose a hybrid language combining the strengths of textual and graphical notations in one concrete syntax for UML actions and present a supporting editor. We also report on a user study that was conducted to evaluate the notation and the editor.

When developing control systems software, mathematically based modelling tools such as Matlab/Simulink are used for design, simulation, and implementation. Thus, a continuous model-based approach does not need to map requirements to, for example, UML class diagrams but to this mathematical representation. In this paper, we build on previous work that has applied the requirements formalism i* to the development of control systems software and present a mapping from i* models to Matlab/Simulink models. During a first manual transformation step, design alternatives are resolved. The second, automated step generates a Matlab/Simulink skeleton model from the i* model. Finally, an interactive step allows incorporating existing hardware and platform components into the skeleton. As a running example, we consider the development of a parking assistant.

Software developed for the space domain often has to deal with extremely long mission times (sometimes in the order of 15 to 20 years). During the lifetime of a mission programming platforms evolve and sometimes disappear forcing migrations or updates. Migration can also be triggered by the appearance of new platforms that can improve scalability, performance. European Space Agency (ESA) is interested in modernization approaches that simplify platform migration and that preserve the business values of systems. The Architecture Driven Modernization (ADM) promoted by the Object Management Group (OMG) proposes to recover the models which represent the business value and proceed with the platform migration in a forward MDA process. This article provides results of a study dedicated to assess the state-of-the-art tools and methods for model driven platform migration, including model-based testing and metrication.

Today, developments of real time embedded systems have to face new challenges. On the one hand, economic laws, such as Time-to-market, require a reliable development process allowing quick design space exploration. On the other hand, fast increasing technology, as stated by the Moore’s law, requires techniques to handle the resulting productivity gap. Model Driven Development has been widely used in response to those issues. Benefits of such approach are numerous and have been demonstrated through several experiments. We present in this paper the Model Driven Development MoPCoM methodology, dedicated to SoC / SoPC design and analysis, and based on the use of the MARTE profile. This approach refines the MDA Y-Chart in order to ease design space exploration and IP integration. We illustrate our approach on Cognitive Radio System development implemented on an FPGA. This work is part of the MoPCoM research project (http://www.mopcom.fr) gathering academic and industrial organizations.

Model-based development is supposed to improve the development efficiency by raising the abstraction level and generating applications instead of manually coding the application in low level languages like C. One of the successful incarnations of this idea is the MATLAB Simulink tool chain. These tools are now widely used in the automotive industry not only to simulate control devices but also to generate product quality code from it. Like with traditional concepts reuse of created models is an issue. When this can be done efficiently, an additional level of effort reduction (and quality improvement) will be achieved. While MATLAB Simulink in combination with code generators provides good support for creating models for single application, and libraries of models, it does not provide sufficient support for more complex reuse scenarios with fine grained variations across the model(s). This paper will extend the approach developed by an automotive car manufacturer to address these issues. After a discussion of the basic concept the paper will put a special focus on support for flexible binding times since this is one of the crucial issues for reusing models across different projects with different need for run-time switchable variations (development/testing) and static decisions for product generation (resource efficiency in terms of code size and run-time). A concrete application supporting the deployment of these concepts in a project, developing mass production control units, is discussed in the following section.

Domain-specific modeling solutions have been promoted for some time in order to improve the productivity of software developers by providing them with modeling environments that are easier to learn, integrate best solutions and provide the possibility to automate software development by generating code from models. This paper presents experiences of developing a network modeling tool in Telefónica using Eclipse GMF. A metamodel based on Common Information Model was used in this development. While we experienced benefits in terms of better usability by domain experts, we also faced challenges such as the high level of expertise required to develop a good enough language and tool, the shortcomings of the tools in providing support for modeling at different abstraction levels, and the difficulties in updating the modeling tool with changes in the metamodel. These challenges must be overcome before the tool can be a part of our development environment.

Service choreographies describe the global communication protocols between services and testing these choreographies is an important task in the context of service-oriented architectures (SOA). Formal modeling of service choreographies makes a model-based testing (MBT) approach feasible. In this paper we present an MBT approach for SOA integration testing based on SAP proprietary choreography models called Message Choreography Models (MCM). In our approach, MCMs are translated into executable UML models using Java as action language. These UML models are used by a UML model execution engine developed by IBM for test generation and model debugging. We describe the achievements and challenges of our approach based on first experimental evaluation conducted at SAP.

Integration of heterogeneous and distributed IT-systems is one of the major cost-driving factors in the software industry. We introduce a model-based approach for information system integration and demonstrate it on the industrial case-study of data integration between the Oracle database management system and the SAP R/3 enterprise resource planning system. Particular focus is on multi-level modeling abstractions, integration conflict analysis (automatic data model matching), semantic reasoning, code generation and tool support.