Metamodel Matching Techniques

Model-Driven Engineering (MDE) is changing the way we build, operate, and maintain our software-intensive systems. Several projects using MDE practices are reporting significant improvements in quality and performance but, to be able to handle these projects, software engineers need a set of technical and interpersonal skills that are currently not widely available. The MDE postgraduate diploma intends to fill this gap by offering a full-time one year formation onMDE. The course syllabus is designed to teach students how to work at a higher abstraction level by the rigorous use of (software) models as the main artifacts in all software engineering activities. Contents include the conceptual framework of MDE plus all techniques and tools (e.g. for defining modeling languages, models, and model transformations) required to successfully complete software engineering projects following a MDE approach. The organizational impact (and challenges) of adopting MDE are exemplified using real industrial experiences. This article describes the MDE Diploma and the lessons that we learned after completing its first edition.

The integration of domain-specific concepts in a model-driven engineering (MDE) approach raises a number of interesting research questions. There are two possibilities to represent these concepts. The first one focuses on models that contain domain-specific concepts only, i.e. domain-specific modelling languages (DSML). The second one advocates the integration of domain-specific concepts in general-purpose models, using what we will refer to in this paper as domain-specific modelling annotation languages (DSMAL). In this position paper, we argue that each approach is particularly suited for specific activities and specific actors, and show how they can be developed and used together. We also highlight the challenges created by the use of two representations, such as the evaluation of models OCL constraints and the synchronisation between the two representations. As an illustration, we present rbacUML, our approach for integrating role-based access control (RBAC) concepts into an MDE approach.

Since its emergence in 2009, DevOps has significantly advanced software development. Numerous studies have explored the evolution of DevOps and its related methodologies. Some of this research has investigated how model-driven engineering (MDE) can enhance the adoption and implementation of CI/CD practices, commonly known as DevOps pipelines. MDE, originating in the 1980s, offers a distinct approach to software development compared to the traditional “code is the model” mindset. This paper examines the potential synergies between MDE and DevOps, specifically reviewing existing studies on the key artifacts of DevOps pipelines. Our findings indicate that current efforts have not yet sufficiently generalized or formalized reusable transformation rules for a DevOps pipeline model and its corresponding meta-model. These elements are crucial for a successful MDE approach. Therefore, this study proposes an application of the model transformation concept to the DevOps pipeline model. Furthermore, it conceptualizes a reusable model transformation solution capable of generating both the DevOps pipeline model and its resulting code from a software architecture model. The broad research presented here identifies requirements for a potentially groundbreaking future DevOps solution.

Hardware-in-the-loop (HIL) testing is an integral part of the development of power system automation solutions. HIL test beds facilitate system-level testing and validation of controllers against their specifications. The information required for HIL test bed configurations is typically scattered across different tools used in the development of power system automation solutions. These tools often have different formats and naming schemes. This implies that a significant effort is required for consolidating data from the tools and for creating valid test configurations from the consolidated data. This paper presents a Model-Driven Engineering (MDE) approach for creating HIL test configurations in a tool-, platform-, and protocol-agnostic manner. It shows how the MDE approach can be applied in practice to derive test configurations based on the information originating from different tools in a semi-automated fashion.

For its promises in terms of increased productivity, Model-driven engineering (MDE) is getting applied increasingly often in both industry and academia. However, most tools currently available are based on the Eclipse Modeling Framework (EMF) and hence based on the Java platform whereas tool support for other platforms is limited. This leads to a language and tool adoption problem for developers of other platforms such as .NET. As a result, few projects on the .NET platform adopt MDE. In this paper, we present the .NET Modeling Framework (NMF), a tool set for model repositories, model-based incrementalization, model transformation, model synchronization and code generation that is now available for a multitude of different operating systems, including Windows, Linux, Android, iOS and Mac. The framework makes intensive use of the C# language as host language for model transformation and synchronization languages, whereas the model repository serialization is compatible with EMF. This solves the language adoption problem for C# programmers and creates a bridge to the EMF platform.

Model-driven engineering (MDE) considers the systematic use of models in software development. A model must be specified through a well-defined modeling language with precise syntax and semantics. In MDE, this syntax is defined by a meta-model. While meta-models tend to be fixed, there are several scenarios that require the customization of existing meta-models. For example, standards of the object management group (OMG) like the knowledge discovery meta-model (KDM) or the diagram definition (DD) are based on the extension of base meta-models according to certain rules. However, these rules are not “ operational ” but are described in natural language and therefore not supported by tools. Although modeling is an activity regulated by meta-models, currently there are no commonly accepted mechanisms to regulate how meta-models can be extended. Hence, in order to solve this problem, we propose a mechanism that allows specifying customization and extension rules for meta-models, as well as a tool that makes it possible to customize the meta-models according to such rules. The tool is based on the Eclipse modeling framework, has been implemented as an Eclipse plugin, and has been validated to guide the extension of OMG standard meta-models, such as KDM and DD.

Model-driven engineering (MDE) promises faster and more reliable software development processes. A key factor of MDE is the transformation of models, allowing a software engineer to use the most appropriate modeling notation for a particular task. The earlier transformations can be applied during software development, the greater the potential cost savings. To that effect, we report on the transformation of aspect-oriented models for reactive systems development, i.e., from a scenario-based requirements model into a UML-based design model. We use Aspect-oriented Use Case Maps (AoUCM) as the requirements notation and Reusable Aspect Models (RAM) as the design notation. While AoUCM is ideally suited for the specification of the system workflow comprised of interactions between the environment and the system, RAM excels in providing a design view of system structure and defining the data dimension of the system including inputs and outputs. As the more abstract AoUCM models are transformed into more concrete RAM models, MDE ensures that the AoUCM workflow specifications do not have to be modeled again in RAM, thus avoiding a duplication of effort. We present transformation algorithms to show that an AoUCM-to-RAM mapping is indeed feasible and report on initial tool support for the transformation.

<p dir="ltr">Model-Driven Engineering (MDE) is a methodology in software development which emphasizes the use of models throughout the development process. Key aspects of MDE include process modelling and enactment, which provide a systemic approach to developing software. Traceability is currently gaining prominence within MDE, since it facilitates the tracking of artefacts through the development and management process, from inception to final output.</p><p dir="ltr">We propose an approach that integrates end-to-end traceability with process modelling. In our research, process models represent MDE workflows that span platform-independent modelling, platform-specific modelling, and code generation phases. Process execution is automated using megamodels and model transformation chains. The generation of end-to-end traceabillity information enables global model traceability, from high-level input models to generated code, forming the basis for traceability analysis.</p><p dir="ltr">We have built an Eclipse-based framework, ProMoTA, to support our approach. ProMoTA extends the Acceleo model transformation language, introducing local traceability support. Our tool suite within ProMoTA encompasses a global traceability map generator and end-to-end traceability analysis modules, providing users with a holistic view of the entire transformation process. To validate the efficacy and versatility of ProMoTA, we modelled and analyzed two distinct systems; a Digital Signal Processing Filter Designer which we both implemented and analyzed, and a WSNbased IoT system which we analyzed. Through analysis using our framework, we demonstrate ProMoTA’s capability to effectively address traceability challenges, underscoring its potential as a tool in modern MDE processes. In particular, ProMoTA allows us to examine global traceability of large systems and processes using change impact and origin tracking analysis techniques.</p>

Nowadays, Web Applications (WAs) are complex software sys- tems, used by multiple users with different roles and often devel- oped to support and manage business processes. Due to the chang- ing nature of the supported processes, WAs need to be easily and quickly modified, to adapt and align them to the processes they support. In recent years, Model Driven Engineering (MDE) ap- proaches have been proposed and used to develop and evolveWAs. However, the definition of appropriate MDE approaches for the de- velopment of flexible process-centric WAs is still limited. In par- ticular, (flexible) workflow models have never been integrated with the models (e.g., presentation, information models) used in MDE approaches to develop this type of applications. In this paper, we present M3D (Model Driven Development with Declare), a tool for developingWAs that integrates three MDE metamodels used to represent the main components of aWA with the metamodel of De- clare, a declarative language to model business processes. The tool exploits and combines the declarative nature of Declare and the ad- vantages of MDE to get an efficient roundtrip engineering support to develop and evolve flexible process-centric WAs.

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.

Modern technological trends like Internet of Things (IoT’s) essentially require prompt development of software systems. To manage this, Model Driven Architecture (MDA) is frequently applied for development of different systems like industry automation, medical, surveillance, tracking and security etc. Image processing is an integral part of such systems. Particularly, image enhancement and classification operations are mandatory in order to effectively recognize objects for different purposes. Currently, such critical image processing operations are not managed through MDA and low level implementations are performed distinctly during system development. This severely delays the system development due to integration issues. Furthermore, system testing becomes problematic as few components of systems are developed through MDA and image processing operations are implemented in isolation. This article introduces a novel framework i.e. MIEORF – Model-driven Image Enhancement and Object Recognition Framework. Particularly, a meta-model is proposed, that allows modeling and visualization of complex image processing and object recognition tasks. Subsequently, an open source customized tree editor (developed using Eclipse Modeling Framework (EMF)) and graphical modeling tool/workbench (developed using Sirius) have been developed (both distributable via eclipse plugin). Consequently, the proposed framework allows modeling and graphical visualization of major image processing operations. Moreover, it provides strong grounds for model transformation operations e.g. Model to Text Transformations (M2T) using Acceleo for generating executable Matlab code. Furthermore, it systematically combines MDA and image processing concepts which are detailed enough to be easily integrated into wide variety of systems such as industrial automation, medical, surveillance, security and biometrics etc. The feasibility of proposed framework is demonstrated via real world medical imagery case study. The results prove that the proposed framework provides a complete solution for modeling and visualization of image processing tasks and highly effective for MDA based systems development.

The specific requirements of developing Internet of Things (IoT) software for public transportation systems should be considered in addition to the problems always observed in IoT system development. After defining the problems encountered in the development of IoT-based public transport systems, the current model-driven engineering (MDE) approaches for IoT development are examined and their applicability for public transport systems is questioned in this paper. Several points of view are given about what new MDE approaches specific to this field should include in order to eliminate the identified deficiencies. Moreover, it is indicated that new MDE approaches should be designed including round-trip engineering to provide high mobility, use of special standards, in-vehicle communication networks and support for different system-on-chips in these public transportation systems.

Owing to the increasing importance of model-driven engineering (MDE) and the changes experienced by software systems over their life cycle, the calculation, representation and visualisation of matches and differences between two different versions of the same model are becoming more necessary and useful. This study shows the need for improvement in the algorithms for calculating the relationships between models and presents a tool to test different implementations, thus reducing the effort required to measure, compare or create new algorithms. To demonstrate the need for improvement and the framework developed, the authors have created different models that conform to the metamodel of a domain-specific language. Subsequently, the authors compared these models using the algorithms of the eclipse modelling framework (EMF) Compare tool, part of the eclipse modeling project, which is the framework of reference for MDE. Thus, in the case study, the authors tool is used to measure the quality of the comparisons performed by EMF Compare.

The OMG's model-driven architecture is quickly attracting attention as a method of constructing systems that offers advantages over traditional approaches in terms of reliability, consistency, and maintainability. The key concepts in the MDA are models that are related by model transformations. However, for the MDA to provide an adequate alternative to existing approaches, it must offer comparable support for software engineering processes such as requirements analysis, design and testing. This paper attempts to explore the application of the last of these processes, testing, to the most novel part of the MDA, that of model transformation. We present a general view of the roles of testing in the different stages of model-driven development, and a more detailed exploration of approaches to testing model transformations. Based on this, we highlight the particular issues for the different testing tasks, including adequacy criteria, test oracles and automatic test data generation. We also propose possible approaches for the testing tasks, and show how existing functional and structural testing techniques can be adapted for use in this new development context.

Today's Web Applications (WAs) are complex multi-user and multi-tenant software systems, used by users with different roles and often developed to support and manage complex business processes. Due to the changing nature of such processes, WAs need to be easily and quickly modified, to be adapted and aligned to the processes they support. In recent years, Model Driven Engineering (MDE) approaches have been used to support the development and the evolution of WAs. However, the definition of appropriate MDE approaches for the development of flexible process-centric WAs is still limited. In particular, flexible workflow models have never been integrated with the models used in MDE approaches to develop this type of applications. This paper proposes an MDE approach for the development and the evolution of flexible process-centric WAs that integrates four MDE metamodels used to represent the main components of a WA with the metamodel of Declare, a declarative language to model business processes. A case study, carried out to validate the feasibility, the correctness and the effectiveness of the proposed approach is presented and discussed.