Model Driven Architecture – Foundations and Applications

We present the Epsilon Generation Language (EGL), a model-to-text (M2T) transformation language that is a component in a model management tool chain. The distinctive features of EGL are described, in particular its novel design which inherits a number of language concepts and logical features from a base model navigation and modification language. The value of being able to use a M2T language as part of an extensible model management tool chain is outlined in a case study, and EGL is compared to other M2T languages.

Model transformations can be defined by a chain or network of sub-transformations, each fulfilling a specific task. Many intermediate models, possibly accompanied by traceability models, are thus generated before reaching the final target(s). There is a need for tools that assist the developer in managing and interpreting this growing amount of MDD artifacts. In this paper we first discuss how a transformation chain can be modeled and executed in a transformation language independent way. We then explore how the available traceability information can be used to generate suitable diagrams for all intermediate and final models. We also propose a technique to visualize all the diagrams along with their traceability information in a single view by using a 3D diagram editor. Finally, we present an example transformation chain that has been modeled, executed and visualized using our tools.

Model driven development suggests to make models the main artifact in software development. To get executable models in most cases code generation to a “traditional” programming language like e.g. Java is used. To obtain customizable code generation template-based approaches are applied, commonly. So, to adapt the generated code to platform specific needs templates are modified by the user. After code generation, in real world application the generated code is often changed e.g. by refactorings. To keep the code and the model synchronous reverse engineering is needed. Many approaches use a Java parser and a mapping from the Java parse tree to the UML model for this task. This causes maintenance issues since every change to a template potentially results in a change to this parse tree - model mapping. To tackle this maintenance problem our solution does not use a common language parser but uses the templates as a grammar to parse the generated code, instead. This way changes to the templates are automatically taken into account in the reverse engineering step. Our approach has been implemented and tested in the Fujaba CASE tool as a part of the model and template-based code generator CodeGen2 [11].

Frameworks and libraries that use annotations are becoming popular. However, there is not enough software engineering support for annotation development. In particular, the validation of constraints in the use of annotations requires further support. In this paper we postulate that annotation frameworks are a projection of the domain model into a programming language model. Using this idea, we have developed a tool that allows the annotation programmer to specify, and then validate the constraints of the annotation framework regarding a given annotated application using a domain model. To validate our approach to the validation of constraints using models, we apply it to the Fraclet annotation framework and compare it to the previous implementation.

This paper is about visual and executable domain-specific modelling languages (DSMLs) that are used at the platform independent level of the Model-Driven Architecture. We deal with DSMLs that are new or evolve rapidly and, as a consequence, have to be prototyped cheaply. We argue that for prototyping a DSML on the platform independent level, its semantics should not only be described in a transformational but also in an operational fashion. For this, we use standard modelling means, i.e. MOF and QVT Relations. We combine operational semantics descriptions with existing metamodel-based editor creation technology. This allows for cheap prototyping of visual interpreters and debuggers. We exemplify our approach with a language for Petri nets and assess the manual work necessary. Finally, we present

EProvide

, an implementation of our approach based on the Eclipse platform, and we identify missing features in the Eclipse tools we used.

Executable modeling allows the models to be executed and treated as prototype to determine the behavior of a system. These models use precise action languages to specify the algorithms and computational details required for execution. These action languages are developed on the basis of UML action semantics metamodel that provides the abstract syntax. The use of a concrete action language makes a traditional model work like an executable one. The actions specified by the action language might involve variables and their data values that are useful to be analyzed in terms of data flow. In this paper, we provide data flow analysis (DFA) of the standard UML action semantics that can be used with executable models. The analysis provides a generic data flow at the abstract syntax level and allows a mapping to any of the action languages providing the concrete syntax. Our approach does not focus on a particular action language; therefore it can easily be applied to any concrete syntax. We apply the proposed approach to a case study and identify the data flow from executable UML state machine.

Model transformations support a model-driven design by providing an automatic translation of abstract models into more concrete ones, and eventually program code. Crucial to a successful application of model transformations is their

correctness

, in the sense that the meaning (semantics) of the models is preserved. This is especially important if the models not only describe the structure but also the intended

behaviour

of the systems. Reasoning about and showing correctness is, however, often impossible as the source and target models typically lack a precise definition of their semantics.

In this paper, we take a first step towards provably correct behavioural model transformations. In particular, we develop transformations from UML Activities (which are visual models) to programs in TAAL, which is a textual Java-like programming language. Both languages come equipped with formal behavioural semantics, which, moreover, have the same semantic domain. This sets the stage for showing correctness, which in this case comes down to showing that the behaviour of every (well-formed) UML Activity coincides with that of the corresponding TAAL program, in a well-defined sense.

By releasing their Model Driven Architecture (MDA) as a new standard, the Object Management Group (OMG) [1] proposed a new development concept toward existing traditional paradigms. It set a new exciting research area in which it would be possible to develop truly independent and powerful programming environments capable of achieving new levels of productivity, performance and maintainability. With this goal in mind, this paper describes a research conducted with the purpose of improving database performance through the union of autonomic computing aspects and MDA. It is widely accepted that the model development approach is gaining importance in IT projects today; therefore the technique discussed here, presents a way of assessing performance, identifying flaws and improving software activities in order to create a self-managed environment. With new defined stereotypes and tagged values; in conjunction with profiling libraries, and relying on autonomic aspects, the proposed extension enables code generation in order to conduct a thorough set of performance analysis, indicating the best suitable database configuration for a given functionality. After setting the underlying problem, explaining tools configuration and concepts and describing the profiling technique, it presents a study based on a real project conducted by the Brazilian Ministry of Defense.

Ladder Diagram (LD) is the most used programming language for Programmable Logical Controllers (PLCs). A PLC is a special purpose industrial computer used to automate industrial processes. Bugs in LD programs are very costly and sometimes are even a threat to human safety. We propose a model driven approach for formal verification of LD programs through model-checking. We provide a metamodel for a subset of the LD language. We define a time Petri net (TPN) semantics for LD programs through an ATL model transformation. Finally, we automatically generate behavioral properties over the LD models as LTL formulae which are then checked over the generated TPN using the model-checkers available in the Tina toolkit. We focus on race condition detection.

With the continuing advances in semiconductor technology driving the rise in complexity of electronic embedded systems, there is a demand for the development of high level modelling environments for computer-aided design. The modelling of highly repetitive structures in graphical form poses a particular challenge if a hierarchical approach is not adopted. This paper proposes a mechanism for describing such component structures in a compact form based upon extensions of the Array Oriented Language (Array-OL). An example is given as to how the structure described is subsequently mapped into VHDL code.

Although labelled graphical, many modelling languages represent important model parts as structured text. We benefit from sophisticated text editors when we use programming languages, but we neglect the same technology when we edit the textual parts of graphical models. Recent advances in generative engineering of textual model editors make the development of such sophisticated text editors practical, even for the smallest textual constructs of graphical languages. In this paper, we present techniques to embed textual model editors into graphical model editors and prove our approach for EMF-based textual editors and graphical editors created with GMF.

Textual concrete syntaxes for models are beneficial for many reasons. They foster usability and productivity because of their fast editing style, their usage of error markers, autocompletion and quick fixes. Furthermore, they can easily be integrated into existing tools such as diff/merge or information interchange through e-mail, wikis or blogs. Several frameworks and tools from different communities for creating concrete textual syntaxes for models emerged during recent years. However, these approaches failed to provide a solution in general. Open issues are incremental parsing and model updating as well as partial and federated views. To determine the capabilities of existing approaches, we provide a classification schema, apply it to these approaches, and identify their deficiencies.

The development process of Domain Specific Languages (DSL) can be tackled from different technical spaces such as XML, Grammarware or Model Driven Engineering (MDE). In the case of using MDE, the definition of a concrete syntax for a textual DSL requires commonly building a bridge between this technical space and Grammarware. Several bridging approaches have been recently proposed in which the existing coupling between concrete and abstract syntaxes causes information duplication in the development process of DSLs. Moreover, reusability of concrete syntaxes has received no attention in these approaches.

In this paper we present the MSS (Metamodel Syntactic Sheets) approach for defining textual concrete syntaxes. MSS is intended to promote the reuse of textual concrete syntaxes and to avoid information duplication. In MSS, metamodels are annotated with syntactic properties and a propagation mechanism reduces the number of annotations required as well as the coupling between concrete and abstract syntaxes. Textual concrete syntaxes can be reused by annotating syntactically the metamodeling language. This reuse makes possible to share syntactic idioms (textual conventions) among different DSLs.

Model-based techniques place modeling at the cornerstone of software development. Because of the large number of domains and levels of abstraction one can find in software systems, a large number of modeling languages is necessary. Modeling languages need to be properly defined regarding concrete syntax in addition to abstract syntax and semantics. Most modeling languages use a graphical concrete syntax, and solutions to model those syntaxes appeared. If those solutions are convincing to support the rapid development of graphical modeling tools, they are often restrictive in the range of possible concrete syntaxes for a given abstract syntax, and rely on dedicated technologies. In previous works, we proposed such a solution based on a representation model which was more flexible in that it abstracted away purely graphical concerns. Those concerns include actual design for representation icons, how the design reacts to representation variations within the icons, possible interactions with an icon, and synchronization between the graphical representation and the graphical model. In this paper, we show how to solve those four last points using the SVG open standard for vector graphics. We propose to define representation icons by SVG templates complemented by layout constraints, a predefined and extensible library of possible user interactions using DOM, and a specific approach based on events to synchronize the graphical representation with the graphical model. Thus, our solution solves the concrete realization of an modeling environment cumulating advantages of a clear separation between abstract and concrete syntaxes at the modeling level, while benefiting from the expertise of the vector graphics community.

Although some techniques for aspect oriented modelling focus on semantic-based composition, there has been a general lack of focus on how to preserve semantics. We address semantics preservation in the context of sequence diagram aspects. We define semantics preservation based on two properties: monotonicity of aspect composition with respect to refinement, and preservation of events in the composed result. We analyse and compare existing sequence diagram aspect techniques with respect to semantics preservation and find that both syntactic based and semantic based aspect weaving techniques have serious challenges to meet semantics preservation.

The increasing complexity of software applications requires improved software development techniques in order to cope with, a.o., software reuse and evolution, the management of heterogeneous concerns, and the retargeting of systems towards new software platforms. The introduction of AOSD (aspect-oriented software development) and the support for MDD (model-driven development) are two important and promising evolutions that can contribute to better control of software complexity. In this paper we present an AOM (Aspect-Oriented Modeling) based framework to promote and enhance the reuse of concerns expressed in UML. We have developed a prototype composition engine implemented in ATL that can be used to compose concern models specified in UML.

Human participation in business processes needs to be addressed in process modeling. BPEL4People with WS-HumanTask covers this concern in the context of BPEL. Bound to specific workflow technology this leads to a number of problems. Firstly, maintaining and migrating processes to new or similar technologies is expensive. Secondly, the low-level, technical standards make it hard to communicate the process models to human domain experts. Model-driven approaches can help to easier cope with technology changes, and present the process models at a higher level of abstraction than offered by the technology standards. In this paper, we extend the model-driven approach with a view-based framework for business process modeling, in which models can be viewed at different abstraction levels and different concerns of a model can be viewed separately. Our approach enables developers to work with meta-models that represent a technical view on the human participation, whereas human domain experts can have an abstract view on human participation in a business process. In order to validate our work, a mapping to BPEL4People technology will be demonstrated.

In this paper we introduce an aspect language that can define cross-cutting effects on a set of UML 2.0 sequence diagrams. The aspects and sequence diagrams are woven at the model level. By basing the weaving upon a formal trace model for sequence diagrams, we ensure that the weaving is semantics-based. We propose the

arbitrary events symbol

as a wildcard mechanism to express zero or more events on a sequence diagram lifeline. The approach is explained by a real-life example, and a weaving tool partially implements the approach.

The increasing size and complexity of software systems requires sophisticated testing methodologies. Since platform limitations could void the results of test suites, especially the embedded systems domain requires testing methodologies that also consider hardware resources. Current approaches for specifying and executing test cases, e.g. approaches based on the UML testing model, do not support the concept of platform testing very well. Deployment descriptions are only used for documentation. In this work, we address this problem by providing an extension to the UML testing profile that covers the modeling of platform testing models, which include realistic deployments, and by

C-PartsSim

, our simulation tool that is capable of executing these platform testing models. With

C-PartsSim

, it is possible to connect specialized simulators at runtime, thereby providing a configurable, platform-specific system simulation for testing. We describe the automatic transformation from scenario models to a tailored simulator instance for a concrete testing scenario and present case studies to demonstrate the flexibility and accuracy of our approach.

In this paper, we deal with errors in metamodels. Metamodels define the abstract syntax of modeling languages. They play a central role in the Model-Driven Architecture. Other artifacts like models or tools are based on them and have to be changed if the metamodel is changed. Consequently, correcting errors in a metamodel can be quite expensive as dependent artifacts have to be adapted to the corrected metamodel. We argue that metamodels should be tested systematically with automated tests. We present a corresponding approach that allows automated metamodel testing based on a test specification. From a test specification, multiple test models can be derived. Each test model defines a potential instance of the metamodel under test. A positive test model defines a potential instance that should be an actual instance of the metamodel; a negative test model defines one that should not. We exemplify our approach with a metamodel for defining a company’s structure. Finally, we present

MMUnit

, an implementation of our approach that builds on the Eclipse platform and integrates the JUnit framework. MMUnit allows to test EMF-based metamodels, which can contain additional constraints, e.g. constraints expressed in OCL.

In requirements engineering, there are several approaches for requirements modeling such as goal-oriented, aspect-driven, and system requirements modeling. In practice, companies often customize a given approach to their specific needs. Thus, we seek a solution that allows customization in a systematic way. In this paper, we propose a metamodel for requirements models (called

core

metamodel

) and an approach for customizing this metamodel in order to support various requirements modeling approaches. The core metamodel represents the common concepts extracted from some prevalent approaches. We define the semantics of the concepts and the relations in the core metamodel. Based on this formalization, we can perform reasoning on requirements that may detect implicit relations and inconsistencies. Our approach for customization keeps the semantics of the core concepts intact and thus allows reuse of tools and reasoning over the customized metamodel. We illustrate the customization of our core metamodel with SysML concepts. As a case study, we apply the reasoning on requirements of an industrial mobile service application based on this customized core requirements metamodel.

In this paper we report on our experience on using the so-called model-driven security approach in an MDA industrial project. In model-driven security, “designers specify system models along with their security requirements and use tools to automatically generate system architectures from the models.” Our report includes a discussion of the languages that we used to model both the functional and the security system’s requirements, as well as a description of the transformation function that we developed to build from the security-design models the system’s access control infrastructure. The report concludes with the lessons about the feasibility and practical industrial relevance of the model-driven security approach that we learned from this experience.

Input models that are not completely checked generate ill-formed output models in MDA transformation processes. Model executability is a means for, at development time, simulating/testing models and thus making them compliant with requirements. At runtime, persistent models bring added values like the monitoring and control of applications through the observation of the active states, the guards which hold true, the occurring events... This paper on purpose presents a Java-based execution engine for the UML

State Machine Diagrams

. In order to incorporate this UML interpreter into MDA tools, the execution semantics of the UML

State Machine Diagrams

is first analyzed and next disambiguated. Execution semantics choices are thus proposed and justified accordingly.

Railroad interlocking software drives specialised micro-devices, known as interlocking controllers. These controllers primarily actuate railroad points and change signal aspects in real-time, based on sensor and timer input. Due to their central function in railroad control, interlocking controllers and their firmware are safety-critical. The firmware programs, which mimic physical relays, are written in variants of domain-specific programming languages based on ladder logic. The programs have to comply with a more abstract specification of allowable states of sections of railroad track and equipment, known as a control table. The translation of a track layout and associated control tables into ladder logic-based code is manual, and hence subject to costly review and rework cycles. In this report, we describe a case study that uses a model-driven tool-chain as an automated alternative to the existing process. The two domain languages, control table and ladder logic, were modelled and transformations were implemented between the two models, and from model to program text. We report on implementation challenges, and describe the outlook and scalability of the approach in this application domain.

This paper reports an industrial experiment made at Thales to use Model Driven Architecture (MDA) for system engineering. System engineering processes are currently mainly document-centric. The main experiment goal was to study the applicability of MDA at the system engineering level. The experiment consisted of setting up a model-driven simulation environment for a maritime surveillance system. The simulation is achieved thanks to 3 models conform to 3 metamodels. The implementation uses the Eclipse Modeling Framework and is written in the Java Programming language. This pilot project met the deadline, the budget and the threshold of desired functionalities. We report the main advances given by the MDA approach in the context of simulation for system engineering.

Composite Applications on top of SAPs implementation of SOA (Enterprise SOA) enable the extension of already existing business logic. In this paper we show, based on a case study, how Model-Driven Engineering concepts are applied in the development of such Composite Applications. Our Case Study extends a back-end business process which is required for the specific needs of a demo company selling wine. We use this to describe how the business centric models specifying the modified business behaviour of our case study can be utilized for business performance analysis where most of the actions are performed by humans. In particular, we apply a refined version of Model-Driven Performance Engineering that we proposed in our previous work and motivate which business domain specifics have to be taken into account for business performance analysis. We additionally motivate the need for performance related decision support for domain experts, who generally lack performance related skills. Such a support should offer visual guidance about what should be changed in the design and resource mapping to get improved results with respect to modification constraints and performance objectives, or objectives for time.

One of the major challenges in today’s complex business environment is the delivery of a complete solution from business architecture design downstream to SOA IT realization. The IBM Service Oriented Modeling and Architecture (SOMA) methodology attempts to address this objective. Our project captures information from business architecture design and presents this information in a graphical user interface for its later utilization by the solution development team, compliant to the SOMA methodology. Our model-driven development (MDD) cycle consists of modeling with XML Schema Definition (XSD), generating code with Eclipse Model Framework (EMF) and Eclipse Graphical Model Framework (GMF), customizing the code, and testing the solution. The tool was tested on a supply chain management scenario. The results demonstrated the feasibility of capturing business design and using the artifacts for IT realization with MDD. Our overall MDD experience is discussed.

The paper presents an approach for developing composite tele-communication services running on mobile phones which takes advantage of the use of model driven techniques as well as the loose coupling paradigm in SOA. A domain-specific UML dialect named SPATEL has been developed which serves as the basis for generating applications that can be deployed in distinct terminals and servers technologies. The composite services typically combines telecommunication enablers - like SMS sending and GSM locali-sation - with traditional IT components accessible over the internet, such as a Yellow Page facility. This work has been conducted in the context of the IST SPICE European collaborative project.

Today, many practitioners have consolidated their experience with software models in collections of design flaws, smells, antipatterns, or guidelines that have a negative impact on quality aspects (such as maintainability). Besides these quality defects, many compilability errors or conformance warnings might occur in a software design. Programming IDEs typically present problems regarding compilability in or near the code (e.g., icons at the line or underlining in the code). Modeling IDEs in MDSD follow a visual paradigm and need a similar mechanism for presenting problems in a clear, consistent, and familiar way. In this paper, we present different visualization concepts for visualizing quality defects and other problems in software models. These concepts use different dimensions such as color, size, or icons to present this information to the user. We used a survey to explore the opinions held by practitioners showing that 89.9% want to be informed about potential defects and prefer icon-, view- and underscore-based concepts to other types of concepts.

Model-Driven Development (MDD) has become a familiar software engineering term in recent years, thanks to the profound influence of the Model Driven Architecture (MDA). Yet MDD, like MDA itself, defines a general framework, and as such is a generic approach rather than a concrete development methodology. Methodology support for MDA has been rather slow in coming, yet even though several MDA-based methodologies have emerged, they have not been objectively analyzed yet. The need remains for a critical appraisal of these methodologies, mainly aimed at identifying their achievements, and the shortcomings that should be addressed. We provide a review of several prominent MDA-based methodologies, and present a criteria-based evaluation which highlights their strengths and weaknesses. The results can be used for assessing, comparing, selecting, and adapting MDA-based methodologies.

Model-Driven Engineering (MDE) has been promoted as a solution to handle the complexity of software development by raising the abstraction level and automating labor-intensive and error-prone tasks. However, few efforts have been made at collecting evidence to evaluate its benefits and limitations, which is the subject of this review. We searched several publication channels in the period 2000 to June 2007 for empirical studies on applying MDE in industry, which produced 25 papers for the review. Our findings include industry motivations for investigating MDE and the different domains it has been applied to. In most cases the maturity of third-party tool environments is still perceived as unsatisfactory for large-scale industrial adoption. We found reports of improvements in software quality and of both productivity gains and losses, but these reports were mainly from small-scale studies. There are a few reports on advantages of applying MDE in larger projects, however, more empirical studies and detailed data are needed to strengthen the evidence. We conclude that there is too little evidence to allow generalization of the results at this stage.