Search

UML profiles offer an intuitive way for developers to build domain-specific modelling languages by reusing and extending UML concepts. Eclipse Papyrus is a powerful open-source UML modelling tool which supports UML profiling. However, with power comes complexity, implementing non-trivial UML profiles and their supporting editors in Papyrus typically requires the developers to handcraft and maintain a number of interconnected models through a loosely guided, labour-intensive and error-prone process. We demonstrate how metamodel annotations and model transformation techniques can help manage the complexity of Papyrus in the creation of UML profiles and their supporting editors. We presentJorvik, an open-source tool that implements the proposed approach. We illustrate its functionality with examples, and we evaluate our approach by comparing it against manual UML profile specification and editor implementation using a non-trivial enterprise modelling language (Archimate) as a case study. We also perform a user study in which developers are asked to produce identical editors using both Papyrus andJorvikdemonstrating the substantial productivity and maintainability benefits thatJorvikdelivers.

Scalability in modeling has many facets, including the ability to build larger models and domain-specific languages (DSLs) efficiently. With the aim of tackling some of the most prominent scalability challenges in model-based engineering (MBE), the MONDO EU project developed the theoretical foundations and open-source implementation of a platform for scalable modeling and model management. The platform includes facilities for building large graphical DSLs, for splitting large models into sets of smaller interrelated fragments, to index large collections of models to speed-up their querying, and to enable the collaborative construction and refinement of complex models, among other features. This paper reports on the tools provided by MONDO that Ikerlan, a medium-sized technology center which in the last decade has embraced the MBE paradigm, adopted in order to improve their processes. This experience produced as a result a set of model editors and related technologies that fostered collaboration and scalability in the development of wind turbine control applications. In order to evaluate the benefits obtained, an on-site evaluation of the tools was performed. This evaluation shows that scalable MBE technologies give new growth opportunities to small- and medium-sized organizations.

Recent research in scalable model-driven engineering now allows very large models to be stored and queried. Due to their size, rather than transferring such models over the network in their entirety, it is typically more efficient to access them remotely using networked services (e.g. model repositories, model indexes). Little attention has been paid so far to the nature of these services, and whether they remain responsive with an increasing number of concurrent clients. This paper extends a previous empirical study on the impact of certain key decisions on the scalability of concurrent model queries on two domains, using an Eclipse Connected Data Objects model repository, four configurations of the Hawk model index and a Neo4j-based configuration of the NeoEMF model store. The study evaluates the impact of the network protocol, the API design, the caching layer, the query language and the type of database, and analyses the reasons for their varying levels of performance. The design of the API was shown to make a bigger difference compared to the network protocol (HTTP/TCP) used. Where available, the query-specific indexed and derived attributes in Hawk outperformed the comprehensive generic caching in CDO. Finally, the results illustrate the still ongoing evolution of graph databases: two tools using different versions of the same backend had very different performance, with one slower than CDO and the other faster than it.

Mining data from remote repositories, such as GitHub and StackExchange, involves the execution of requests that can easily reach the limitations imposed by the respective APIs to shield their services from overload and abuse. Therefore, data mining clients are left alone to deal with such protective service policies which usually involves an extensive amount of manual implementation effort. In this work we present RestMule, a framework for handling various service policies, such as limited number of requests within a period of time and multi-page responses, by generating resilient clients that are able to handle request rate limits, network failures, response caching, and paging in a graceful and transparent manner. As a result, RestMule clients generated from OpenAPI specifications (i.e. standardized REST API descriptors), are suitable for intensive data-fetching scenarios. We evaluate our framework by reproducing an existing repository mining use case and comparing the results produced by employing a popular hand-written client and a RestMule client.

We present an approach for defining the abstract and concrete syntax of UML profiles and their equivalent Papyrus graphical editors using annotated Ecore metamodels, driven by automated model-to-model and model-to-text transformations. We compare our approach against manual UML profile specification and implementation using Archimate, a non-trivial enterprise modelling language, and we demonstrate the substantial productivity and maintainability benefits it delivers.

Traditional model management programs, such as transformations, often perform poorly when dealing with very large models. Although many such programs are inherently parallelisable, the execution engines of popular model management languages were not designed for concurrency. We propose a scalable data and rule-parallel solution for an established and feature-rich model validation language (EVL). We highlight the challenges encountered with retro-fitting concurrency support and our solutions to these challenges. We evaluate the correctness of our implementation through rigorous automated tests. Our results show up to linear performance improvements with more threads and larger models, with significantly faster execution compared to interpreted OCL.

Software is critical to the majority of functionality in avionics and aerospace systems. The amount of safety-related software in avionics is growing rapidly (doubling in size around every four years), and the costs of software programmes in industry are increasingly unaffordable – safety-related code can cost upwards of USD $150 per line. At the same time, demands from avionics customers for increased scope and new functionality is increasing, and quality is non-negotiable: it is fixed by standards and safety requirements. The SECT-AIR project is addressing these cost and demand issues by focusing on automation in software engineering, with particular emphasis on model-based development. In this paper we provide an overview of the motivation behind the project, which started in 2016, and some of the key tasks it will carry out to help improve productivity, increase customer scope and maintain quality.

EMF and GMF are powerful frameworks for implementing tool support for modelling languages in Eclipse. However, with power comes complexity, implementing a graphical editor for a modelling language using EMF and GMF requires developers to handcraft and maintain several detailed interconnected models through a loosely guided, labour-intensive, and error-prone process. We demonstrate how the application of metamodel annotation and model transformation techniques can help to manage the complexity of GMF and EMF and deliver significant productivity, quality, and maintainability benefits. We present Eugenia, an open-source tool that implements the proposed approach, illustrate its functionality with an example, evaluate it through an empirical study, and report on the community's response to the tool.

While the majority of research on Model-Based Software Engineering revolves around open-source modelling frameworks such as EMF, the use of commercial and closed-source modelling tools such as RSA, Rhapsody, MagicDraw and PTC Integrity Modeller appears to be the norm in industry at present. This technical gap can prohibit industrial users from reaping the benefits of state-of-the-art research-based tools in their practice. In this paper, we discuss an attempt to bridge a proprietary UML modelling tool (PTC Integrity Modeller), which is used for model-based development of safety-critical systems at Rolls-Royce, with an open-source family of languages for automated model management (Epsilon). We present the architecture of our solution, the challenges we encountered in developing it, and a performance comparison against the tool's built-in scripting interface.

A metamodel has been defined as: a model of a model; a definition of a language; a description of abstract syntax; and a description of a domain. Because of these varied definitions, it is difficult to explain why metamodels are constructed, what can be done with them, and how they are built. This tutorial introduces the key concepts, terminology and philosophy behind metamodelling, focusing on its use for language engineering , and expressed in a way that is intended to be accessible to researchers who may be more familiar with the use of traditional context-free grammar techniques. We highlight the main differences between metamodelling and grammar-based approaches, describe how to map metamodelling concepts and techniques to grammar concepts and techniques, and highlight some of the strengths and weaknesses of metamodelling via a set of small, but realistic examples.

Softeam has over 20 years of experience providing UML-based modelling solutions, such as its Modelio modelling tool, and its Constellation enterprise model management and collaboration environment. Due to the increasing number and size of the models used by Softeam's clients, Softeam joined the MONDO FP7 EU research project, which worked on solutions for these scalability challenges and produced the Hawk model indexer among other results. This paper presents the technical details and several case studies on the integration of Hawk into Softeam's toolset. The first case study measured the performance of Hawk's Modelio support using varying amounts of memory for the Neo4j backend. In another case study, Hawk was integrated into Constellation to provide scalable global querying of model repositories. Finally, the combination of Hawk and the Epsilon Generation Language was compared against Modelio for document generation: for the largest model, Hawk was two orders of magnitude faster.

Model-driven engineering introduces additional challenges for controlling and managing software evolution. Today, tools exist for generating model editors and for managing models with transformation, validation, merging and weaving. There is limited support, however, for model migration--a development activity in which instance models are updated in response to metamodel evolution. In this paper, we propose conservative copy--a style of model transformation that we believe is well-suited to model migration--and Epsilon Flock--a compact model-to-model transformation language tailored for model migration. The proposed structures are evaluated by comparing the conciseness of model migration strategies written in different styles of transformation language, using several examples of evolution taken from UML and the graphical modelling framework.

COMMitMDE was the 1st international workshop on Collaborative Modelling in MDE, held on the 4th of October 2016 as a satellite event of the 19th International Conference on Model Driven Engineering Languages and Systems (MoDELS 2016), St. Malo, France. The goal of the workshop was to bring together researchers and practitioners in order to investigate (i) the potential impact of collaborative software engineering methods and principles into Model-Driven Engineering (MDE) practices and (ii) how MDE methods and techniques can support collaborative software engineering activities. The 1st COMMitMDE workshop provided a forum to discuss the state of research and practice on collaborative MDE, to create new synergies between tool vendors, researchers, and practitioners, to inform the community about the new means for collaborative MDE, and to reect on the needs and research gaps in the collaborative MDE area.

Epsilon is an extensible platform of integrated and task-specific languages for model management. With solutions to the 2011 TTC Hello World case, this paper demonstrates some of the key features of the Epsilon Object Language (an extension and reworking of OCL), which is at the core of Epsilon. In addition, the paper introduces several of the task-specific languages provided by Epsilon including the Epsilon Generation Language (for model-to-text transformation), the Epsilon Validation Language (for model validation) and Epsilon Flock (for model migration)., Comment: In Proceedings TTC 2011, arXiv:1111.4407

The final publication is available at Springer via http://dx.doi.org/10.1007%2Fs10270-011-0211-2, Model transformation is one of the pillars of model-driven engineering (MDE). The increasing complexity of systems and modelling languages has dramatically raised the complexity and size of model transformations as well. Even though many transformation languages and tools have been proposed in the last few years, most of them are directed to the implementation phase of transformation development. In this way, even though transformations should be built using sound engineering principles—just like any other kind of software—there is currently a lack of cohesive support for the other phases of the transformation development, like requirements, analysis, design and testing. In this paper, we propose a unified family of languages to cover the life cycle of transformation development enabling the engineering of transformations. Moreover, following an MDE approach, we provide tools to partially automate the progressive refinement of models between the different phases and the generation of code for several transformation implementation languages., This work has been sponsored by the Spanish Ministry of Science and Innovation with project METEORIC (TIN2008-02081), and by the R&D program of the Community of Madrid with projects “e-Madrid" (S2009/TIC-1650). Parts of this work were done during the research stays of Esther and Juan at the University of York, with financial support from the Spanish Ministry of Science and Innovation (grant refs. JC2009-00015, PR2009-0019 and PR2008-0185).

Model-driven engineering (MDE) involves the construction and manipulation of many models of different kinds in an engineering process. In principle, models can be used in the product engineering lifecycle in an end-to-end manner for representing requirements, designs and implementations, and assisting in deployment and maintenance. The manipulations applied to models may be manual, but they can also be automated--for example, using model transformations, code generation, and validation. To enhance automated analysis, consistency and coherence of models used in an MDE process, it is useful to identify, establish and maintain trace-links between models. However, the breadth and scope of trace-links that can be used in MDE is substantial, and managing trace-link information can be very complex. In this paper, we contribute to managing the complexity of traceability information in MDE in two ways: firstly, we demonstrate how to identify the different kinds of trace-links that may appear in an end-to-end MDE process; secondly, we describe a rigorous approach to defining semantically rich trace-links between models, where the models themselves may be constructed using diverse modelling languages. The definition of rich trace-links allows us to use tools to maintain and analyse traceability relationships.

Appropriate test models that can satisfy complex constraints are required for testing model management programs in order to build confidence in their correctness. Models have inherently complex structures and are often required to satisfy non-trivial constraints which makes them time consuming, labour intensive and error prone to construct manually. Automated capabilities are therefore required, however, existing fully-automated model generation tools cannot generate models that satisfy arbitrarily complex constraints. In this paper, we propose a semi-automated approach towards the generation of such models. A new framework named Epsilon Model Generator EMG that implements this approach is presented. The framework supports the development of model generators that can produce random and reproducible test models that satisfy complex constraints.

This paper complements previous empirical studies on teaching Model-driven Engineering (MDE) by reporting on the authors’ attempt at introducing MDE to undergrad students. This is important because: (1) today’s students are tomorrow’s professionals and industrial adoption depends also on the availability of trained professionals and (2) observing problems in the introduction of MDE in the more controlled environment of a classroom setting allows us to identify additional adoption factors, more at the individual level, to be taken into account after in industrial settings. As we report herein, this attempt was largely unsuccessful. We will analyze what went wrong, what we learned from the process and the implications this has for both future endeavors of introducing MDE in both educational and professional environments, particularly regarding human/socio-technical factors to be considered.

In Model-Driven Engineering (MDE), models conform to metamodels. In flexible modelling, engineers construct example models with free-form drawing tools; these examples may later need to conform to a metamodel. Flexible modelling can lead to errors: drawn elements that should represent the same domain concept could instantiate different types; other drawn elements could be left untyped. We propose a novel type inference approach to calculating types from example models, based on the Classification and Regression Trees (CART) algorithm. We describe the approach and evaluate it on a number of randomly generated models, considering the accuracy and precision of the resultant classifications. Experimental results suggest that on average 80% of element types are correctly identified. In addition, the results reveal a correlation between the accuracy and the ratio of known-to-unknown types in a model.

Automatic generation of textual artefacts (including code, documentation, configuration files, build scripts, etc.) from models in a software development process through the application of model-to-text (M2T) transformation is a common MDE activity. Despite the importance of M2T transformation, contemporary M2T languages lack support for developing transformations that scale with the size of the input model. As MDE is applied to systems of increasing size and complexity, a lack of scalability in M2T (and other) transformation languages hinders industrial adoption. In this paper, we propose a form of runtime analysis that can be used to identify the impact of source model changes on generated textual artefacts. The structures produced by this runtime analysis, property access traces, can be used to perform efficient source-incremental transformation: our experiments show an average reduction of 60% in transformation execution time compared to non-incremental (batch) transformation.

Analysis of resource usage and precise correlation with the workload that triggered it is essential in order to conduct capacity planning in computing environments. Virtualisation enables resource optimisation and is widely used in grid, cluster and cloud computing. We present an automated approach for resource usage analysis in a virtualised environment that can support capacity planning for web applications. The approach uses Domain Specific Modelling Languages (DSMLs) and model management techniques, which support tool interoperation and provide precise ways for describing resource and request logs and requirements, and automatically generate different outputs that feed into the capacity planning process. The approach is demonstrated using a proof-of-concept example involving a media streaming web application, and the results of the analysis are presented and discussed.

Hawk is a modular and scalable framework that supports monitoring and indexing large collections of models stored in diverse version control repositories. Due to the aggregate size of indexed models, providing a reliable, usable, and fast mechanism for querying Hawk's index is essential. This paper presents the integration of Hawk with an existing model querying language, discusses the efficiency challenges faced, and presents an approach based on the use of derived features and indexes as a means of improving the performance of particular classes of queries. The paper also reports on the evaluation of a prototype that implements the proposed approach against the Grabats benchmark query, focusing on the observed efficiency benefits in terms of query execution time. It also compares the size and resource use of the model index against one created without using such optimizations.

We demonstrate the application of Model Driven Engineering techniques to support the development of research grant proposals. In particular, we report on using model-to-text transformation and model validation to enhance productivity and consistency in research proposal writing, and present unanticipated opportunities that were revealed after establishing an MDE infrastructure. We discuss the types of models and the technologies used, reflect on our experiences, and assess the productivity benefits of our MDE solution through automated analysis of data extracted from the version control repository of a successful grant proposal; our evaluation indicates that the use of MDE techniques improved productivity by at least 58%.

Model-to-text (M2T) transformation is an important model management operation, used to implement code and documentation generation, model serialisation (enabling model interchange), and model visualisation and exploration. Despite the importance of M2T transformation, contemporary M2T transformation languages cannot be used to easily produce transformations that scale well as the size of the input model increases, which limits their applicability in practice. In this paper, we propose an extension to template-based M2T languages that adds support for signatures, lightweight and concise proxies for templates, which are used to reduce the time taken to re-execute a M2T transformation in response to changes to the input model. We report our initial results in applying signatures to two existing M2T transformations, which indicate a reduction of 33-47% in transformation execution time.

This chapter presents the EU-funded MADES FP7 project that aims to develop an effective model-driven methodology to improve the current practices in the development of real-time embedded systems for avionics and surveillance industries. MADES developed an effective SysML/MARTE language subset, and a set of new tools and technologies that support high-level design specifications, validation, simulation, and automatic code generation, while integrating aspects such as component re-use. This chapter illustrates the MADES methodology by means of a car collision avoidance system case study; it presents the underlying MADES language, the design phases, and the set of tools supporting on one hand model verification and validation and, on the other hand, automatic code generation, which enables the implementation on execution platforms such as state-of-the-art FPGAs.

We present a framework and methodology to benchmark NoSQL stores for large scale model persistence. NoSQL technologies potentially improve performance of some applications and provide schema-less data-structures, so are particularly suited to persisting large and heterogeneous models. Recent studies consider only a narrow set of NoSQL stores for large scale modelling. Benchmarking many technologies requires substantial effort due to the disparate interface each store provides. Our experiments compare a broad range of NoSQL stores in terms of processor time and disc space used. The framework and methodology is evaluated through a case study that involves persisting large reverse-engineered models of open source projects. The results give tool engineers and practitioners a basis for selecting a store to persist large models.

The Eclipse platform has played a very significant role in the evolution of software engineering research over the last few years as it has provided mature infrastructure for the development of orthogonal but interoperable prototypes in areas including model driven engineering, code analysis, data visualisation, software measurement and testing and language development. The academic community has in turn embraced Eclipse and has contributed several tools back as open source projects (such as IMP, GEF3D, Mylyn, ATL, Epsilon etc) - some of which have been brought under the umbrella of the Eclipse Foundation.

A metamodel is variously defined as a model of a model, a definition of a language, a description of abstract syntax, and a description of a domain. It is all of these things and more. Metamodels can be confusing, and explaining why they are constructed, what you can do with them, and how they are built can be challenging, especially when trying to bridge the gap between the modelware and grammarware communities. In this example-driven mini-tutorial, we introduce the key concepts and ideas behind metamodelling and explain why metamodels are useful, and particularly how they differ from grammar-based approaches to language development. We give some tips on how grammarware researchers can explain what they do to modelware researchers, and vice versa, in the spirit of interdisciplinarity and improving collaboration.

Spreadsheets are widely used to support software development activities. They have been used to collect requirements and software defects, to capture traceability information between requirements and test cases, and in general, to fill in gaps that are not covered satisfactorily by more specialised tools. Despite their widespread use, spreadsheets have received little attention from researchers in the field of Model Driven Engineering. In this paper, we argue for the usefulness of model management support for querying and modifying spreadsheets, we identify the conceptual gap between contemporary model management languages and spreadsheets, and we propose an approach for bridging it. We present a prototype that builds atop the Epsilon and Google Drive platforms and we evaluate the proposed approach through a case study that involves validating and transforming software requirements captured using spreadsheets.

Model management is the discipline of manipulating models in support of Model-Driven Engineering (MDE) scenarios of interest. Model management may be supported and implemented via different operations – e.g., model transformation, validation, and code generation. We motivate the concepts and processes of model management, present a practical model management framework – Epsilon – and briefly indicate how it has been used to solve significant model management problems ’in the wild’.

Scalability in Model-Driven Engineering (MDE) is often a bottleneck for industrial applications. Industrial scale models need to be persisted in a way that allows for their seamless and efficient manipulation, often by multiple stakeholders simultaneously. This paper compares the conventional and commonly used persistence mechanisms in MDE with novel approaches such as the use of graph-based NoSQL databases; Prototype integrations of Neo4J and OrientDB with EMF are used to compare with relational database, XMI and document-based NoSQL database persistence mechanisms. Benchmarking of these technologies is then performed, to measure and compare their relative performance in terms of memory usage and execution time.

Designing a domain-specific language (DSL) is a collaborative, iterative and incremental process between domain experts and software engineers. Existing tools for implementing DSLs produce powerful and interoperable domain-specific editors, but are resistant to language change and require considerable technical expertise to use. We present EuGENia Live, a tool for designing (graphical) DSLs. EuGENia Live runs in a web browser, supports on-the-fly meta-model editing, and produces DSLs that can be exported and used with the Eclipse Modeling Framework. As well as presenting the design and implementation of EuGENia Live, we discuss potential benefits to our underlying approach, and challenges for future work on flexible modelling tools.

The benefits of Model Driven Development may be achieved through exploitation of its potential for automation. Automated model verification is one of the most important examples of this. The usage of automated model verification in everyday software engineering practice is far from widespread. One of the reasons for this is that model designers do not have the necessary background in mathematical methods. An approach where model designers can remain working in their domain while the verification is performed on demand, automatically and transparently, is desirable. We present one such approach using a tool chain built atop mature, popular and widespread technologies. Our approach was verified on industrial experiments from the embedded systems domain in the fields of avionics and surveillance.

The majority of contemporary model management languages that support MDE tasks (such as model transformation, validation and code generation) require models to be captured using metamodelling architectures such as Ecore and MOF. In practice, a limited subset of modelling tools --- with the exception of some UML tools --- build atop such architectures. For many modelling languages and tools outside of the UML/Ecore/MOF family, plain XML is a widely-used model storage and exchange format. In this paper, we argue for the importance of integrating XML-based models in the MDE process. We identify the challenges involved in integrating XML-based models into MDE processes, and we present a technical solution that addresses these challenges, which enables developers to perform a wide range of model management tasks on models captured in XML.

This paper provides a summary of the contents of the ECMFA 2011 tutorial titled "Integrated Model Management with Epsilon". The aim of the tutorial is to provide an overview of the principles, practices and standards related to MDE and present the Epsilon model management platform, which provides an extensible architecture and set of consistent and interoperable task-specific model management languages and tools for automating a wide range of MDE operations.

Traceability of software artefacts has been recognized as an important factor for supporting various software development activities. However, establishing traceability requires a substantial investment in effort. Even when an initial set of traceability links has been established, this set is subject to gradual degradation as the associated artefacts are modified, e.g., due to the evolutionary nature of software development. To avoid this, traceability must be constantly maintained and evolved. The manual maintenance of traceability can be time consuming and error-prone. This paper focuses on reducing the manual effort incurred in performing traceability maintenance tasks. This is achieved by introducing a dedicated mechanism in the Traceability Metamodelling Language, which is used for detecting and evolving problematic trace links. A concrete example is used to demonstrate the practicality and usefulness of our approach.

The final publication is available at Springer via http://dx.doi.org/10.1007/978-3-642-16145-2_8, Proceedings of 13th International Conference, MODELS 2010, Oslo, Norway, October 3-8, 2010, Model transformation is one of the pillars of Model-Driven Engineering (MDE). The increasing complexity of systems and modelling languages has dramatically raised the complexity and size of model transformations. Even though many transformation languages and tools have been proposed in the last few years, most of them are directed to the implementation phase of transformation development. However, there is a lack of cohesive support for the other phases of the transformation development, like requirements, analysis, design and testing. In this paper, we propose a unified family of languages to cover the life-cycle of transformation development. Moreover, following an MDE approach, we provide tools to partially automate the progressive refinement of models between the different phases and the generation of code for specific transformation implementation languages., Work funded by the Spanish Ministry of Science (project TIN2008-02081 and grants JC2009-00015,PR2009-0019), the R&D programme of the Madrid Region (project S2009/TIC-1650), and the European Commission’s 7th Framework programme (grants #218575 (INESS), #248864 (MADES)).

A change to a software development artefact, such as source code or documentation, can affect the integrity of others. Many contemporary software development environments provide tools that automatically manage (detect, report and reconcile) integrity. For instance, incremental background compilation can reconcile object code with changing source code and report calls to a method that are inconsistent with its definition. Although models are increasingly first-class citizens in software development, contemporary development environments are less able to automatically detect, manage and reconcile the integrity of models than the integrity of other types of artefact. In this paper, we discuss the scalability and efficiency problems faced when managing model integrity for two categories of change that occur in MDE. We present a framework to support the incremental management of model integrity, evaluating the efficiency of the proposed approach atop Eclipse and EMF.

peer-reviewed EMF and GMF are powerful frameworks for implementing tool support for modelling languages in Eclipse. However, with power comes complexity; implementing a graphical editor for a modelling language using EMF and GMF requires developers to hand craft and maintain several low level-interconnected models through a loosely-guided, labour-intensive and error-prone process. In this paper we demonstrate how the application of model transformation techniques can help with taming the complexity of GMF and EMF and deliver significant productivity and quality benefits. In particular we demonstrate EuGENia, a widely-used tool that adopts a single-sourcing approach and advanced model transformation techniques for automatically producing and maintaining the low-level models required by EMF and GMF. We evaluate EuGENia through automated testing and substantial feedback from researchers and practitioners within the Eclipse modelling community.

Model-Driven Engineering tasks, such as simulation or transformation, often cannot be carried out directly on the models at hand; models often need to be decorated with additional information, and this information is in some cases not accounted for by existing metamodels. Moreover, engineers often need to experiment with alternative and complementary types of model decorations, particularly when carrying out more exploratory styles of development. Heavyweight approaches to decoration are not convenient in such situations. In this paper we demonstrate the limitations of existing model decoration mechanisms and tools, and present a novel approach that enables engineers to capture decoration information in the form of separate interchangeable models. The approach allows engineers to transparently and programmatically navigate decorations as if they were embedded in the decorated model.

In their recent book, Mens and Demeyer state that Model-Driven Engineering introduces additional challenges for controlling and managing software evolution. Today, tools exist for generating model editors and for managing models with transformation, validation, merging and weaving. There is limited support, however, for model migration - a development activity in which instance models are updated in response to metamodel evolution. In this paper, we describe Epsilon Flock, a model-to-model transformation language tailored for model migration that contributes a novel algorithm for relating source and target model elements. To demonstrate its conciseness, we compare Flock to other approaches.

The final publication is available at Springer via http://dx.doi.org/10.1007/978-3-642-16145-2_26, Proceedings of 13th International Conference, MODELS 2010, Oslo, Norway, October 3-8, 2010, We define inter-modelling as the activity of building models that describe how modelling languages should be related. This includes many common activities in Model Driven Engineering, like the specification of model-to-model transformations, the definition of model matching and model traceability constraints, the development of inter-model consistency maintainers and exogenous model management operators. Recently, we proposed a formal approach to specify the allowed and forbidden relations between two modelling languages by means of bidirectional declarative patterns. Such specifications were used to generate graph rewriting rules able to enforce the relations in (forward and backward) model-to-model transformation scenarios. In this paper we extend the usage of patterns for two further inter-modelling scenarios – model matching and model traceability – and report on an EMF-based tool implementing them. The tool allows a high-level analysis of specifications based on the theory developed so far, as well as manipulation of traces by compilation of patterns into the Epsilon Object Language., Work funded by the Spanish Ministry of Science (project TIN2008-02081 and grants JC2009-00015, PR2009-0019), the R&D programme of the Madrid Region (project S2009/TIC-1650), the European Commission’s 7th Framework programme (grant #248864 (MADES)), and the Engineering and Physical Sciences Research Council (EPSRC) (grant EP/E034853/1)

Calculating differences between models is an important and challenging task in Model Driven Engineering. Model differencing involves a number of steps starting with identifying matching model elements, calculating and representing their differences, and finally visualizing them in an appropriate way. In this paper, we provide an overview of the fundamental steps involved in the model differencing process and summarize the advantages and shortcomings of existing approaches for identifying matching model elements. To assist potential users in selecting one of the existing methods for the problem at stake, we investigate the trade-offs these methods impose in terms of accuracy and effort required to implement each one of them.

The Eclipse Graphical Modeling Framework (GMF) provides substantial infrastructure and tooling for developing diagram-based editors for modelling languages atop the Eclipse platform. It is widely accepted that implementing a visual editor using the built-in GMF facilities is a particularly complex and error-prone task and requires a steep learning curve. We present an approach that raises the level of abstraction at which a visual editor is specified. The approach uses annotations at the metamodel level. Annotations are used for producing the required low-level intermediate GMF models necessary for generating an editor via model-to-model transformations.

Critical systems must be shown to be acceptably safe to deploy and use in their environment. The size, scale, heterogeneity, and distributed nature of these increasingly complex systems makes them difficult to verify and analyse. Additionally, domain experts use a variety of languages to model and build their systems. We present an automated safety analysis technique, Fault Propagation and Transformation Analysis, and explain how it can be used for automatically calculating the failure behaviour of an entire system from the failure behaviours of its components. We outline an implementation of the technique in the Epsilon model management platform, allowing it to be used with state-of-the-art model management languages and tools, and making it applicable to a variety of different domain-specific modelling languages.

The Object Constraint Language (OCL) can be used to capture structural constraints in the context of the abstract syntax of modelling languages (metamodels) defined in the MOF metamodelling architecture. While the expression language of OCL has been revised and updated a number of times since its inception, the constructs used for capturing constraints (invariants) have remained unchanged. In this paper we argue that the abstract and concrete syntax of OCL invariants should also be updated to address a number of shortcomings and render OCL more usable in a contemporary modelling environment. To support our arguments we have implemented the proposed extensions in the prototype Epsilon Validation Language (EVL). To demonstrate the benefits delivered, we present and discuss a concrete example.

Domain-specific languages (DSLs) can simplify the development of complex software systems by providing domain-specific abstractions. However, the complexity of some domains has led to a number of DSLs that are themselves complex, limiting the original benefits of using DSLs. We show how to develop DSLs as abstractions of other DSLs by transfering translational approaches for textual DSLs into the domain of modelling languages. We argue that existing model transformation languages are at too low a level of abstraction for succinctly expressing transformations between abstract and concrete DSLs. Patterns identified in such model transformations can be used to raise the level of abstraction. We show how we can allow part of the transformation to be expressed using the concrete syntax of the concrete DSL.