Abstract Model-driven engineering (MDE) seeks to abstract and automate software development through the systematic use of models and transformations. Despite its conceptual rigor, its tools often impose cognitive burdens that hinder adoption and fluency. This paper explores how modeling tools function as cognitive artifacts that mediate, extend, and sometimes constrain reasoning. Drawing on Heidegger’s phenomenology of tool use and Piaget’s theory of cognitive schema adaptation, we articulate a theoretical framework explaining how transparency and accommodation shape the modeling experience. We argue that achieving cognitive harmony in MDE tools requires aligning architectural mediation with human cognition, a relational condition we conceptualize as cognitive resonance . The paper concludes with principles for the design of cognitively informed modeling tools, connecting philosophy, cognitive science, and model-driven engineering.

The MODELS conference series is the premier venue for model-driven software and systems engineering covering all aspects of modeling, from languages and methods to tools and applications. MODELS 2023 took place in Västerås, Sweden, from 1 to 6 October, 2023, as the ACM/IEEE 26th International Conference on Model-Driven Engineering Languages and Systems. A total of 122 papers were submitted to the conference. The Foundations track of MODELS 2023 received 83 submissions of which 15 were accepted, while the Practice track received 39 submissions of which 15 were accepted. The combined acceptance rate was 24.6%.

Abstract We present a framework for evaluating language workbenches’ capabilities for co-evolution of graphical modeling languages, modeling tools and models. As with programming, maintenance tasks such as language refinement and enhancement typically account for more work than the initial development phase. Modeling languages have the added challenge of keeping tools and existing models in step with the evolving language. As domain-specific modeling languages and tools have started to be used widely, thanks to reports of significant productivity improvements, some language workbench users have indeed reported problems with co-evolution of tools and models. Our tool-agnostic evaluation framework aims to cover changes across the whole language definition: the abstract syntax, concrete syntax, and constraints. Change impact is assessed for knock-on effects within the language definition, the modeling tools, semantics via generators, and existing models. We demonstrate the viability of the framework by evaluating MetaEdit+, EMF/Sirius and Jjodel, providing a detailed evaluation process for others to repeat with their tools. The results of the evaluation show differences among the tools: from editors not opening correctly or at all, through highlighting of items requiring manual intervention, to fully automatic updates of languages, models and editors. We call for industry to evaluate their tool choices with the framework, tool developers to extend their tool support for co-evolution, and researchers to refine the evaluation framework and evaluations presented.

This special section contains high-quality papers in the topics of Prof. Antonio Vallecillo’s research. This set of papers has been compiled in appreciation to Prof. Vallecillo’s career and his contributions to the software engineering community in general and the modeling community in particular. After his recent retirement, this special section opens with a hindsight to Prof. Vallecillo’s fruitful and varied career, where he made contributions in several different dimensions. Then, a set of selected papers in the fields of uncertainty, modeling, CPSs and AI to honor Prof. Vallecillo’s contributions is presented.

The increasing complexity of modern systems leads to an increasing amount of artifacts that are used along the model-based software and systems development lifecycle. This also includes model transformations, which serve for mapping models between representations, e.g., for verification and validation purposes. Model repositories manage this variety of artifacts and promote reusability, but should also enable the bundling of compatible artifacts. Therefore, model transformations should be reused and arranged into transformation chains to support more complex transformation scenarios. The resulting transformation should correspond to the user’s interest in terms of quality criteria such as model coverage, transformation coverage, and number of transformation steps, thus assembling such chains becomes a multi-objective problem. A novel multi-objective approach for exploring possible transformation chains residing in model repositories is presented. MOMoT, a model-driven optimization framework, is leveraged to explore the transformation space spanned by the repository. For demonstration, three differently populated repositories are considered. We have extended MOMoT with an exhaustive, multi-objective search that explores the entire model transformation space defined by graph transformation rules, allowing all possible transformation chains to be considered as solution. Accordingly, the optimal solutions were identified in the demonstration cases with negligible computation time. The approach assists modelers when there are multiple chains for transforming an input model to a specified output model to consider. Our evaluation shows that the approach elicits all legitimate transformation chains, thus enabling the modelers to consider trade-offs in view of multiple criteria selection.

In Model-Driven Engineering, metamodels define the vocabulary of concepts and relations that designers use to define a wide range of artifacts, including models, transformations, and editors. Therefore, whenever a metamodel undergoes modifications, the depending artifacts may no longer be valid, and consistency needs to be repaired through coupled evolution techniques. While several approaches have been proposed over the last decades, they are artifact- and domain-specific and do not facilitate the reuse of migration strategies. Indeed, migration strategies are often hard-coded for a given project in a specific domain. In this paper, we propose the novel concept of migration patterns to leverage reuse across different domains and projects. The approach extends the existing Edelta framework and has been evaluated by considering several case studies identified in a systematic literature review.

Summary Models are core assets in Model‐Driven Engineering (MDE). They are pervasively used throughout software development processes to leverage automation, increase cost‐effectiveness, and enhance quality factors. Model repositories have been successfully proposed to enforce reuse and elicit correlations among modeling artifacts, enabling storing operations on model‐based artifacts and collaborative modeling features. Maintaining and improving the quality of modeling artifacts is mandatory for software quality scale‐ups. Limiting the exploration of datasets and repositories of models to individual artifacts might reduce the ability to capture insights and reuse opportunities. This paper proposes AMINO, an analytics tool for model repositories supporting the discovery and quality evaluation of modeling ecosystems.

Summary As model‐driven engineering gains traction and poses as the new paradigm for software engineering, it raises a need for efficient approaches and tools to manage, discover, and retrieve relevant modeling artifacts. Hence, industry and academia are conceiving effective ways to store, search, and retrieve heterogeneous model artifacts that employ advanced discovery mechanisms. This paper presents MDEForge‐Search, a novel approach to discovering heterogeneous model artifacts over MDEForge, a distributed cloud‐based model repository. We designed advanced discovery mechanisms that retrieve heterogeneous artifacts within their context (megamodel) and reuse them across model management services. In addition, a domain‐specific approach has been proposed to formulate queries in terms of keywords, search tags, conditional operators, quality model assessment services and a transformation chain discoverer. Finally, the applicability of our approach was assessed in a recommender system modeling framework, which, thanks to the operated integration, can rely on the availability of more than 5000 model artifacts currently persisted in our cloud‐based model repository.

Abstract Model-driven engineering has been widely applied in software development, aiming to facilitate the coordination among various stakeholders. Such a methodology allows for a more efficient and effective development process. Nevertheless, modeling is a strenuous activity that requires proper knowledge of components, attributes, and logic to reach the level of abstraction required by the application domain. In particular, metamodels play an important role in several paradigms, and specifying wrong entities or attributes in metamodels can negatively impact on the quality of the produced artifacts as well as other elements of the whole process. During the metamodeling phase, modelers can benefit from assistance to avoid mistakes, e.g., getting recommendations like metaclasses and structural features relevant to the metamodel being defined. However, suitable machinery is needed to mine data from repositories of existing modeling artifacts and compute recommendations. In this work, we propose MemoRec, a novel approach that makes use of a collaborative filtering strategy to recommend valuable entities related to the metamodel under construction. Our approach can provide suggestions related to both metaclasses and structured features that should be added in the metamodel under definition. We assess the quality of the work with respect to different metrics, i.e., success rate, precision, and recall. The results demonstrate that MemoRec is capable of suggesting relevant items given a partial metamodel and supporting modelers in their task.

Abstract Low‐code development platforms (LCDPs) aim to simplify software systems' development by providing easy‐to‐use graphical interfaces and drag‐and‐drop facilities. The system behaviors are defined through available data handling and workflow mechanisms enabling the specification of business processes from users that do not have strong programming skills. However, the number of LCDPs has grown significantly over the last few years. Consequently, it is not easy for inexpert users to understand their differences, especially in terms of provided modeling constructs. In this article, we analyze and compare eight low‐code development platforms by focusing on their capabilities for specifying business processes. The analysis exploits business process modeling and notation (BPMN) as a reference modeling language. Thus, the core elements of BPMN are leveraged to analyze the workflow mechanisms provided by each of the analyzed LCDP. The article explains different types of process flows and data handling means of the different LCDPs aiming to give potential users objective elements that can be used to make educated decisions when selecting LCDPs.

Nowadays, while modeling environments provide users with facilities to specify different kinds of artifacts, e.g., metamodels, models, and transformations, the possibility of learning from previous modeling experiences and being assisted during modeling tasks remains largely unexplored. In this paper, we propose NEMO, a recommender system based on an Encoder-Decoder neural network to assist modelers in performing model editing operations. NEMO learns from past modeling activities and performs predictions employing a deep learning technique. Such an algorithm has been successfully applied in machine translation to convert a text from a language to another foreign language and vice versa. An empirical evaluation on a dataset of BPMN change-based persistent model demonstrates that the technique permits learning from existing operations and effectively predicting the next editing operations with considerably high prediction accuracy. In particular, NEMO gets 0.977 as precision/recall and 0.992 as success rate score by the best performance.

Over the last few years, industry and academia have proposed several Low-Code and Model-driven Engineering (MDE) platforms to ease the engineering process of the Internet of things (IoT) systems. However, deciding whether such engineering platforms meet the minimum required software quality standards is not straightforward. Software quality can be defined as the degree to which a software system achieves its intended goal. Various software quality standards have been established to aid in the software quality assessment process; however, due to the nature of engineering IoT platforms, such models may not entirely suit the IoT domain. This paper presents a model for assessing the software quality of Low-Code and MDE platforms for engineering IoT platforms. The proposed software quality model is based on and extends the ISO/IEC 25010:2011 software product quality model standard. It is intended to assist IoT practitioners in assessing and establishing quality requirements for engineering IoT platforms. To determine the effectiveness of the proposed model, we used it to evaluate the quality of 17 IoT engineering platforms, and the results obtained are promising.

Abstract Like any software artifacts, metamodels are evolving entities that constantly change over time for different reasons. Changing metamodels by keeping them consistent with other existing artifacts is an error-prone and tedious activity without the availability of automated support. In this paper, we foster the adoption of metamodel refactorings collected in a curated catalog. The Edelta framework is proposed as an operative environment to provide modelers with constructs for specifying basic refactorings and evolution operators, to define a complete metamodel refactoring catalog. The proposed environment has been used to implement the metamodel refactorings available in the literature and make them executable. A detailed discussion on how modelers can use and contribute to the definition of the catalog is also given.

Abstract The last few years have witnessed a significant growth of so-called low-code development platforms (LCDPs) both in gaining traction on the market and attracting interest from academia. LCDPs are advertised as visual development platforms, typically running on the cloud, reducing the need for manual coding and also targeting non-professional programmers. Since LCDPs share many of the goals and features of model-driven engineering approaches, it is a common point of debate whether low-code is just a new buzzword for model-driven technologies, or whether the two terms refer to genuinely distinct approaches. To contribute to this discussion, in this expert-voice paper, we compare and contrast low-code and model-driven approaches, identifying their differences and commonalities, analysing their strong and weak points, and proposing directions for cross-pollination.

3 states that "Codebots [7] uses UML to specify domain models that are consumed to automatically generate target artefacts, including complete REST APIs, client libraries, Swagger API documentation, and a JSON Schema definition for each domain object."

Abstract Metamodels play a crucial role in any model-based application. They underpin the definition of models and tools, and the development of model management operations, including model transformations and analysis. Like any software artifacts, metamodels are subject to evolution to improve their quality or implement unforeseen requirements. Metamodels can be defined in terms of existing ones to increase the separation of concerns and foster reuse. However, the induced coupling can give additional evolution complexity, and dedicated support is needed to avoid breaking metamodels defined in terms of those being changed. This paper presents a tool-supported approach that can automatically analyze the available metamodels and alert modelers in case of change operations that can give place to invalid situations like dangling references. The approach has been implemented in the Edelta development environment and successfully applied to metamodels retrieved from a publicly available Ecore models dataset.

Over the last decade, several repositories have been proposed by the Model-Driven Engineering (MDE) community to enable the reuse of modeling artifacts and foster empirical studies to analyze specifications and tools made available by MDE researchers and practitioners. In this respect, different approaches have been proposed to measure the quality of, e.g., models, metamodels, and transformations, with respect to characteristics defined by quality models. However, when a modeling ecosystem is available, measuring the constituting artifacts singularly might not be enough. This paper proposes a quality assessment approach, which considers the relationships among the artifacts under analysis as part of the quality measurement process. For instance, to assess the quality of model transformations, further than measuring their structural characteristics, users might be interested in quality aspects like coverage and information loss related to the depending metamodels and the way models are consumed by transformations, respectively. The proposed approach is based on weaving models, which permit to link quality definitions of different kinds of artifacts, and it can generate Epsilon Object Language (EOL) programs by means of a model-to-code transformation to perform the specified quality assessment process.

Abstract Modeling is a ubiquitous activity in the process of software development. In recent years, such an activity has reached a high degree of intricacy, guided by the heterogeneity of the components, data sources, and tasks. The democratized use of models has led to the necessity for suitable machinery for mining modeling repositories. Among others, the classification of metamodels into independent categories facilitates personalized searches by boosting the visibility of metamodels. Nevertheless, the manual classification of metamodels is not only a tedious but also an error-prone task. According to our observation, misclassification is the norm which leads to a reduction in reachability as well as reusability of metamodels. Handling such complexity requires suitable tooling to leverage raw data into practical knowledge that can help modelers with their daily tasks. In our previous work, we proposed AURORA as a machine learning classifier for metamodel repositories. In this paper, we present a thorough evaluation of the system by taking into consideration different settings as well as evaluation metrics. More importantly, we improve the original AURORA tool by changing its internal design. Experimental results demonstrate that the proposed amendment is beneficial to the classification of metamodels. We also compared our approach with two baseline algorithms, namely gradient boosted decision tree and support vector machines. Eventually, we see that AURORA outperforms the baselines with respect to various quality metrics.

Low-code development platforms (LCDPs) are easy to use visual environments that are being increasingly introduced and promoted by major IT players to permit citizen developers to build their software systems even if they lack a programming background. Understanding and evaluating the LCDP to be employed for the particular problem at hand are difficult tasks mainly because decision-makers have to choose among hundreds of heterogeneous platforms, which are difficult to evaluate without dedicated support. Thus, a detailed classification is needed to elaborate on the existing low-code platforms and to help users find out the most appropriate platforms based on their requirements.In this paper, a technical survey of different LCDPs is presented by relying on a proposed conceptual comparative framework. In particular, by analyzing eight representative LCDPs, a corresponding set of features have been identified to distil the functionalities and the services that each considered platform can support. The final aim is facilitating the understanding and the comparison of the low-code platforms that can best accommodate given user requirements.

Abstract In 2017 and 2018, two events were held—in Marburg, Germany, and San Vigilio di Marebbe, Italy, respectively—focusing on an analysis of the state of research, state of practice, and state of the art in model-driven engineering (MDE). The events brought together experts from industry, academia, and the open-source community to assess what has changed in research in MDE over the last 10 years, what challenges remain, and what new challenges have arisen. This article reports on the results of those meetings, and presents a set of grand challenges that emerged from discussions and synthesis. These challenges could lead to research initiatives for the community going forward.

Conventional wisdom on model transformations in Model-Driven Engineering (MDE) suggests that they are crucial components in modeling environments to achieve superior automation, whether it be refactoring, simulation, or code generation. While their relevance is well-accepted, model transformations are challenging to design, implement, and verify because of the inherent complexity that they must encode. Thus, defining transformations by chaining existing ones is key to success for enhancing their reusability. This paper proposes an approach, based on well-established algorithms, to support modellers when multiple transformation chains are available to bridge a source metamodel with a target one. The all-important goal of selecting the optimal chain has been based on the quality criteria of coverage and information loss. The feasibility of the approach has been demonstrated by means of experiments operated on chains obtained from transformations borrowed from a publicly available repository.

Metamodels are at the core of any modeling ecosystem. As their evolution is inevitable, the management of artifacts which depend on these metamodels is a complicated task. Restoring the validity of the corrupted artifacts after a metamodel evolution in a (semi-)automated manner is intrinsically difficult especially when considering the exact impact of the evolution on the restoring process. In this paper, we propose a generic approach to automatically quantify and identify the impact of metamodel evolution on two related artifacts: models and transformations. The approach starts from the evolution definition and generates OCL queries that can be executed on these artifacts to obtain the impacted elements. The knowledge gained from the impact analysis may then guide the user in the decision on whether to proceed with the evolution or to revert it.

Manual classification methods of metamodel repositories require highly trained personnel and the results are usually influenced by the subjectivity of human perception. Therefore, automated metamodel classification is very desirable and stringent. In this work, Machine Learning techniques have been employed for metamodel automated classification. In particular, a tool implementing a feed-forward neural network is introduced to classify metamodels. An experimental evaluation over a dataset of 555 metamodels demonstrates that the technique permits to learn from manually classified data and effectively categorize incoming unlabeled data with a considerably high prediction rate: the best performance comprehends 95.40% as success rate, 0.945 as precision, 0.938 as recall, and 0.942 as F1 score.

Although Model-Based Software Engineering (MBE) is a widely accepted Software Engineering (SE) discipline, no agreed-upon core set of concepts and practices (i.e., a Body of Knowledge) has been defined for it yet. With the goals of characterizing the contents of the MBE discipline, promoting a global consistent view of it, clarifying its scope with regard to other SE disciplines, and defining a foundation for the development of educational curricula on MBE, this paper proposes the contents for a Body of Knowledge for MBE. We also describe the methodology that we have used to come up with the proposed list of contents, as well as the results of a survey study that we conducted to sound out the opinion of the community on the importance of the proposed topics and their level of coverage in the existing SE curricula.

Over the years, a number of approaches have been proposed on the description of systems and software in terms of multiple views represented by models. This modelling branch, so-called multi-view software and system modelling, praises a differentiated and complex scientific body of knowledge. With this study, we aimed at identifying, classifying, and evaluating existing solutions for multi-view modelling of software and systems. To this end, we conducted a systematic literature review of the existing state of the art related to the topic. More specifically, we selected and analysed 40 research studies among over 8600 entries. We defined a taxonomy for characterising solutions for multi-view modelling and applied it to the selected studies. Lastly, we analysed and discussed the data extracted from the studies. From the analysed data, we made several observations, among which: (i) there is no uniformity nor agreement in the terminology when it comes to multi-view artefact types, (ii) multi-view approaches have not been evaluated in industrial settings and (iii) there is a lack of support for semantic consistency management and the community does not appear to consider this as a priority. The study results provide an exhaustive overview of the state of the art for multi-view software and systems modelling useful for both researchers and practitioners.

Model transformations are key elements of model-driven engineering, where they are used to automate the manipulation of models. However, they are typed with respect to concrete source and target meta-models, making their reuse for other (even similar) meta-models challenging. To improve this situation, we propose capturing the typing requirements for reusing a transformation with other meta-models by the notion of a typing requirements model (TRM). A TRM describes the prerequisites that a model transformation imposes on the source and target meta-models to obtain a correct typing. The key observation is that any meta-model pair that satisfies the TRM is a valid reuse context for the transformation at hand. A TRM is made of two domain requirement models (DRMs) describing the requirements for the source and target meta-models, and a compatibility model expressing dependencies between them. We define a notion of refinement between DRMs and see meta-models as a special case of DRM. We provide a catalogue of valid refinements and describe how to automatically extract a TRM from an ATL transformation. The approach is supported by our tool TOTEM. We report on two experiments—based on transformations developed by third parties and meta-model mutation techniques—validating the correctness and completeness of our TRM extraction procedure and confirming the power of TRMs to encode variability and support flexible reuse.

Models and model transformations, the two core constituents of Model-Driven Engineering, aid in software development by automating, thus taming, error-proneness of tedious engineering activities. In many cases, the result of these automated activities is an overwhelming amount of information. This is the case of one-to-many model transformations that, e.g. in model-based design-space exploration, can potentially generate a massive amount of candidate models (i.e., solution space) from one single source model. In our scenario, from one design model we generate a set of possible implementation models on which timing analysis is run. The aim is to find the best model from a timing perspective. However, multiple implementation models can have equally good analysis results. Therefore, the engineer is expected to investigate the solution space for making a final decision, using criteria which fall outside the analysis' criteria themselves. Since candidate models can be many and very similar to each other, manually finding differences and commonalities is an impractical and error-prone task. In order to provide the engineer with an expressive representation of models' commonalities and differences, we propose the use of modelling with uncertainty. We achieve this by elevating the solution space to a first-class status, adopting a compact notation capable of representing the solution space by means of a single model with uncertainty. Commonalities and differences are thus represented by means of uncertainty points for the engineer to easily grasp them and consistently make her decision without manually inspecting each model individually.

Model transformations are considered to be the "heart" and "soul" of Model Driven Engineering, and as a such, advanced techniques and tools are needed for supporting the development, quality assurance, maintenance, and evolution of model transformations. Even though model transformation developers are gaining the availability of powerful languages and tools for developing, and testing model transformations, very few techniques are available to support the understanding of transformation characteristics. In this paper, we propose a process to analyze model transformations with the aim of identifying to what extent their characteristics depend on the corresponding input and target met models. The process relies on a number of transformation and metamodel metrics that are calculated and properly correlated. The paper discusses the application of the approach on a corpus consisting of more than 90 ATL transformations and 70 corresponding metamodels.

In Model-Driven Engineering (MDE) metamodels play a key role since they underpin the specification of different kinds of modeling artifacts, and the development of a wide range of model management tools. Consequently, when a metamodel is changed modelers and developers have to deal with the induced coupled evolutions i.e., adapting all those artifacts that might have been affected by the operated metamodel changes. Over the last years, several approaches have been proposed to deal with the coupled evolution problem, even though the treatment of changes is still a time consuming and error-prone activity. In this paper we propose an approach supporting users during the adaptation steps that cannot be fully automated.~The approach has been implemented by extending the EMFMigrate language and by exploiting the user input facility of the Epsilon Object Language. The approach has been applied to cope with the coupled evolution of metamodels and model-to-text transformations

In Model-Driven Engineering bidirectionality in transformations is regarded as a key mechanism. Recent approaches to non-deterministic transformations have been proposed for dealing with non-bijectivity. Among them, the JTL language is based on a relational model transformation engine which restores consistency by returning all admissible models. This can be regarded as an uncertainty reducing process: the unknown uncertainty at design-time is translated into known uncertainty at run-time by generating multiple choices. Unfortunately, little changes in a model usually correspond to a combinatorial explosion of the solution space. In this paper, we propose to represent the multiple solutions in a intensional manner by adopting a model for uncertainty. The technique is applied to JTL demonstrating the advantages of the proposal.

In Model-Driven Engineering, models are primary artifact manipulated by means of automated transformations. Recently, a notion of uncertainty has been introduced in models permitting modelers to postpone design decisions in case of lack of information. Interestingly, other forms of model uncertainty are induced by bidirectional transformations. In fact, in certain situations more than one admissible solution is in principle possible, despite most of the current languages generate only one model at time, possibly not the desired one. In this paper, the uncertainty due to the solution multiplicity in bidirectional transformations is discussed. In particular, we propose to represent the models in the solution space as concretizations of an uncertain model because there are cases where the responsibility of identifying the solution must be left to the modeler. The problem is illustrated by a round-tripping scenario realized with the JTL transformation language.

Metamodels are a key concept in Model-Driven Engineering. Any artifact in a modeling ecosystem has to be defined in accordance to a metamodel prescribing its main qualities. Hence, understanding common characteristics of metamodels, how they evolve over time, and what is the impact of metamodel changes throughout the modeling ecosystem is of great relevance. Similarly to software, metrics can be used to obtain objective, transparent, and reproducible measurements on metamodels too. In this paper, we present an approach to understand structural characteristics of metamodels. A number of metrics are used to quantify and measure metamodels and cross-link different aspects in order to provide additional information about how metamodel characteristics are related. The approach is applied on repositories consisting of more than 450 metamodels.

Software systems increasingly require to deal with continuous evolution. In this paper we present the EVOSS tool that has been defined to support the upgrade of free and open source software systems. EVOSS is composed of a simulator and of a fault detector component. The simulator is able to predict failures before they can affect the real system. The fault detector component has been defined to discover inconsistencies in the system configuration model. EVOSS improves the state of the art of current tools, which are able to predict a very limited set of upgrade faults, while they leave a wide range of faults unpredicted.

Despite the flourishing of languages to describe software architectures, existing Architecture Description Languages (ADLs) are still far away from what it is actually needed. In fact, while they support a traditional perception of a Software Architecture (SA) as a set of constituting elements (such as components, connectors and interfaces), they mostly fail to capture multiple stakeholders concerns and their design decisions that represent a broader view of SA being accepted today. Next generation ADLs must cope with various and ever evolving stakeholder concerns by employing semantic extension mechanisms.

Software development is witnessing the increasing need of version management techniques for supporting the evolution of model-based artefacts. In this respect, metamodels can be considered one of the basic concepts of model-driven engineering and are expected to evolve during their life-cycle. As a consequence, models conforming to changed metamodels have to be updated for preserving their well-formedness. This paper deals with the co-adaptation problems by proposing higher-order model transformations which take a difference model recording the metamodel evolution and produce a model transformation able to co-evolve the involved models.

The notion of class (or object pattern) as defined in most object-oriented languages is formalized using known techniques from algebraic specifications. Inheritance can be viewed as a relation betweeen classes, which suggests how classes can be arranged in hierarchies. The hierarchies contain two kinds of information: on the one hand, they indicate how programs are structured and how code is shared among classes; on the other hand, they give information about compatible assignment rules, which are based on subtyping. In order to distinguish between code sharing, which is related to implementational aspects, and functional specialization, which is connected to the external behavior of objects, we introduce an algebraic specification-based formalism, by which one can specify the behavior of a class and state when a class inherits another one. It is shown that reusing inheritance can be reduced to specialization inheritance with respect to a virtual class. The class model and the two distinct aspects of inheritance allow the definition ofcleaninterconnection mechanisms between classes leading to new classes which inherit from old classes their correctness and their semantics.

Reusing provably correct (pieces of) software not only simplifies the task of designing correct software systems, but also decreases the costs of their development. The problem of designing a class (in the sense of object oriented programming methodology) which inherits from those of a given library and whose instances respond to given messages, is reduced to the problem of symbolically deriving a specification from another one using the interfaces of the given classes as productions. The standard algebraic specifications and productions are enriched with keywords which can place standard properties of operations, which can enhance the expressiveness of the specifications or which can guide the choice of productions and drive the search in the space of all derivable specifications.>