Abstract. Model Driven Engineering (MDE) received a lot of attention in the last years, both from academia and industry. However, there is still a debate on which basic concepts form the foundation of MDE. The Model Driven Architecture (MDA) from the OMG does not provided clear answers to this question. This standard instead provides a complex set of interdependent technologies. This paper is the first of a series aiming at defining the foundations of MDE independently from a particular technology. A megamodel is introduced in this paper and incrementally refined in further papers from the series. This paper is devoted to a single concept, the concept of model, and to a single relation, the RepresentationOf relation. The lack of strong foundations for the MDA ’ 4-layers meta-pyramid leads to a common mockery: "So, MDA is just about Egyptology?!". This paper is the pilot of the series called "From Ancient Egypt to Model Driven Engineering". The various episodes of this series show that Egyptology is actually a good model to study MDE. 1

Metamodel evolution poses a threat to the applicability of Model-Driven Development to large scale projects. The problem is caused by incompatibilities between metamodel revisions. These render models that conform to the older version of the metamodel non-conformant to the newer version. An approach to addressing this problem is co-evolution of models with their respective metamodels. In this paper we introduce the problem of synchronizing models with evolving metamodels and outline an approach to addressing it efficiently. The aim of the proposed approach is to minimize the effort required to perform model migration in face of metamodel changes. To provide deeper insights into the envisioned approach, we demonstrate preliminary solutions to the problem of change detection between two metamodel revisions. Furthermore, we present an approach to model-to-model transformations, using a conservative copying algorithm, which regulates the retainment of instances during model migration. 1

Recovering the architecture of large evolving software is challenging. The first problem to be solved is to define what "software architecture" means in the company, and which architectural viewpoints are required by each stakeholder. In order to solve this problem, this paper provides a metamodel-driven implementation of the View Set Scenario. This paper shows how metamodels help in defining architectural viewpoints and how metamodels can be use to drive architecture recovery processes. The concepts presented in this paper were identified over the last decade in the context of a tight collaboration with Dassault Systmes, one of the largest software companies in Europe. The process pattern identified is however general and can be applied in other contexts. This process fits in the MDA and ADM approaches from the OMG. It also complies with the IEEE Standard 1471 for software architecture.

Model Driven Engineering (MDE) received a lot of attention in the last years, both from academia and industry. However, there is still a debate on which basic concepts form the foundation of MDE. The Model Driven Architecture (MDA) from the OMG does not provided clear answers to this question. This standard instead provides a complex set of interdependent technologies. This paper is the first of a series aiming at defining the foundations of MDE independently from a particular technology. A megamodel is introduced in this paper and incrementally refined in further papers from the series. This paper is devoted to a single concept, the concept of model, and to a single relation, the RepresentationOf relation. The lack of strong foundations for the MDA' 4-layers meta-pyramid leads to a common mockery: "So, MDA is just about Egyptology?!". This paper is the pilot of the series called "From Ancient Egypt to Model Driven Engineering". The various episodes of this series show that Egyptology is actually a good model to study Model Driven Engineering.

The true value of domain-specific modeling is found not in a domain-specific modeling language (DSML) but rather in the models that are created using that DSML. Changes to a physical system can be modeled, and the resulting executable model then is a working version of the physical system. Unfortunately, if the model of the domain---or metamodel---is changed, all models that were defined using that metamodel may require maintenance to have semantics that correctly represent the existing system. This paper introduces a visual modeling environment that allows for the evolution of modeling environments using XSL stylesheets as the execution language.

Abstract. Domain-specific modeling promises to increase productivity by offering modeling languages tailored to a problem domain. Such modeling languages are typically defined by a metamodel. In consequence of changing requirements and technological progress, the problem domains and thus the metamodels are subject to change. Manually migrating models to a new version of their corresponding metamodel is costly, tedious and error-prone and heavily hampers cost-efficient model-based development in practice. The coupled evolution of a metamodel and its models is a sequence of metamodel changes and their corresponding model migrations. These coupled changes are either metamodelspecific or metamodel-independent. Metamodel-independent changes can be reused to evolve different metamodels and their models which leads to reduction of migration effort. Tool support is necessary in order to benefit from potential reuse. We propose a language that allows for decomposition of a migration into manageable, modular coupled changes. It provides a reuse mechanism for metamodel-independent changes, but is at the same time expressive enough to cater for complex, metamodelspecific changes. 1

Software maintenance and evolution are the most costly and time consuming activities during the software development life cycle. One of the biggest challenges of software evolution is to adapt a software system to the ever-changing requirements from users or operating environments. An ideal goal is to encapsulate these requirements into a high-level abstraction, which can be used to drive large-scale adaptation of the underlying software implementation. Model-Driven Engineering (MDE) is one of the enabling techniques that support this objective, in that it allows the domain experts or application designers to synthesize various software artifacts from high-level models that represent domain concepts or system design logic. The state-of-the-art MDE techniques, however, lack support for advanced processes and constructive methods involved within the context of the evolution of software systems. With respect to large legacy systems written in disparate programming languages,

Model-based development promises to increase productivity by offering modeling languages tailored to a specific domain. Such modeling languages are typically defined by a metamodel. In response to changing requirements and technological progress, the domains and thus the metamodels are subject to change. Manually migrating existing models to a new version of their metamodel is tedious and error-prone. Hence, adequate tool support is required to support the maintenance of modeling languages. This paper introduces COPE, an integrated approach to specify the coupled evolution of metamodels and models to reduce migration effort. With COPE, a language is evolved by incrementally composing modular coupled transformations that adapt the metamodel and specify the corresponding model migrations. This modular approach allows to combine the reuse of recurring transformations with the expressiveness to cater for complex transformations. We demonstrate the applicability of COPE in practice by modeling the coupled evolution of two existing modeling languages.

As complex software and systems development projects need models as an important planning, structuring and development technique, models now face issues resolved for software earlier: models need to be versioned, differences captured, syntactic and semantic correctness checked as early as possible, documented, presented in easily accessible forms, etc. Quality management needs to be established for models as well as their relationship to other models, to code and to requirement documents precisely clarified and tracked. Business and product requirements, product technologies as well as development tools evolve. This also means we need evolutionary technologies both for models within a language and if the language evolves also for an upgrade of the models. This chapter discusses the state of the art in model management and evolution and sketches what is still necessary for models to become as usable and used as software.

Domain-Specific Modeling (DSM) is an innovative software development methodology that raises the specification of software to graphical models at a high-level of abstraction using domain concepts available in a language that is defined by a metamodel. Using DSM, models become first-class entities in the construction of software systems, and therefore model evolution becomes as important as code evolution in traditional software development. Model transformation is a core technology of DSM that converts a source model to a target model, which plays a significant role in supporting model evolution activities. A common approach toward model transformation is to write transformation rules in a specialized model transformation language. Although such languages provide powerful capabilities to automate model transformations, their usage may present challenges to those who are unfamiliar with a specific model transformation language or a particular metamodel definition. In addition, in the collaborative modeling situations when model evolution knowledge needs to be exchanged and reused, most model transformation