Model-driven Engineering Tools Research Articles

Model-Driven Engineering Techniques and Tools for Machine Learning-Enabled IoT Applications: A Scoping Review.

This paper reviews the literature on model-driven engineering (MDE) tools and languages for the internet of things (IoT). Due to the abundance of big data in the IoT, data analytics and machine learning (DAML) techniques play a key role in providing smart IoT applications. In particular, since a significant portion of the IoT data is sequential time series data, such as sensor data, time series analysis techniques are required. Therefore, IoT modeling languages and tools are expected to support DAML methods, including time series analysis techniques, out of the box. In this paper, we study and classify prior work in the literature through the mentioned lens and following the scoping review approach. Hence, the key underlying research questions are what MDE approaches, tools, and languages have been proposed and which ones have supported DAML techniques at the modeling level and in the scope of smart IoT services.

Teaching Interaction using State Diagrams

To make computational thinking appealing to young learners, initial programming instruction looks very different now than a decade ago, with increasing use of graphics and robots both real and virtual. After the first steps, children want to create interactive programs, and they need a model for this. State diagrams provide such a model. This paper documents the design and implementation of a Model-Driven Engineering tool, SD Draw, that allows even primary-aged children to draw and understand state diagrams, and create modifiable app templates in the Elm programming language using the model-view-update pattern standard in Elm programs. We have tested this with grade 4 and 5 students. In our initial test, we discovered that children quickly understand the motivation and use of state diagrams using this tool, and will independently discover abstract states even if they are only taught to model using concrete states. To determine whether this approach is appropriate for children of this age we wanted to know: do children understand state diagrams, do they understand the role of reachability, and are they engaged by them? We found that they are able to translate between different representations of state diagrams, strongly indicating that they do understand them. We found with confidence p<0.001 that they do understand reachability by refuting the null hypothesis that they are creating diagrams randomly. And we found that they were engaged by the concept, with many students continuing to develop their diagrams on their own time after school and on the weekend.

Guest editorial to the theme section on AI-enhanced model-driven engineering

This theme section brings together the latest research at the intersection of artificial intelligence (AI) and model-driven engineering (MDE). Over the past years, we have witnessed a substantial rise of AI successfully applied to different domains, including software development and MDE. Dedicated events at the intersection of AI and MDE have been created, too, such as the MDE Intelligence workshop series co-located with the MODELS conference. This theme section covers research contributions integrating AI components into MDE approaches—increasing the current benefits of MDE processes and tools and pushing the limits of “classic” MDE with the goal to provide software and systems engineers with the right techniques to develop the next generation of highly complex model-based systems—and applications of MDE to the development of AI components. In total, nine submissions were accepted in the theme section after a thorough peer-reviewing process.

Model-driven round-trip engineering for TinyOS-based WSN applications

Wireless Sensor Network (WSN) applications working on TinyOS operating system is widely used in various areas. However, the requirement of managing the power constraints makes TinyOS different from ordinary systems and hence building WSNs with TinyOS can be a challenging and time-consuming task. As successfully applied in many other domains, model-driven engineering (MDE) can facilitate the design and implementation of such applications. Within this context, the researchers have performed noteworthy studies on deriving various MDE approaches and tools. However, these studies do not support the synchronization between TinyOS application models and the generated programs especially when any change is made in the programs. Hence, in this paper, we introduce a model-driven round-trip engineering (RTE) methodology in which both the MDE of TinyOS applications and synchronization between TinyOS instance models and corresponding code are provided with the use of a toolchain. A domain-specific modeling language, called DSML4TinyOS is used for the MDE of such applications while existing TinyOS programs can be reverse engineered in an environment, called RE4TinyOS. Models retrieved from the existing programs can be automatically processed again with DSML4TinyOS. Evaluation results showed that it is possible to obtain the configurations of the TinyOS applications completely just modeling with DSML4TinyOS whereas the same process leads the automatic creation of almost half of the module parts of these applications. Moreover, the time required for developing such systems from scratch decreased approximately to its half. The results also showed that both model-code synchronization and the integration of existing TinyOS applications which do not have system models previously, into the proposed MDE are possible with using RE4TinyOS. RE4TinyOS succeeded in the reverse engineering of all main parts of the TinyOS applications taken from the official TinyOS Github repository and generated models were able to be visually processed in the MDE environment for further modifications.

Model-Driven Engineering for End-Users in the Loop in Smart Ambient Systems

At the heart of cyber-physical and ambient systems, the user should permanently benefit from applications adapted to the situation and her/his needs. To do this, she/he must be able to configure her/his software environment and be supported as much as possible in that task. To this end, an intelligent &amp;ldquo;engine&amp;rdquo; assembles software components that are present in the ambient environment at the time and makes unanticipated applications emerge. The problem is to put the user &amp;ldquo;in the loop&amp;rdquo;, i.e., provide adapted and intelligible descriptions of the emerging applications, and present them so that the user can accept, modify or reject them. Besides, user feedback must be collected to feed the engine&amp;rsquo;s learning process. Our approach relies on Model-Driven Engineering (MDE). However, differently from the regular use of MDE tools and techniques by engineers to develop software and generate code, our focus is on end-users. Models of component assemblies are represented and made editable for them. Based on a metamodel that supports modeling and de- scription of component-based applications, a user interface provides multi-faceted representations of the emerging applications and captures user feedback. Our solution relies on several domain- specific languages and a transformation process, based on the established MDE tools (Gemoc studio, Eclipse Modeling Framework, EcoreTools, Sirius, Acceleo). It works in conjunction with the intelligent engine that builds the emerging applications and to which it provides learning data.

Advances and Challenges for Model and Data Engineering

Advances and Challenges for Model and Data Engineering

StreamGen

Distributed streaming applications, i.e., applications that process massive streams of data in a distributed fashion, are becoming increasingly popular to tame the velocity and the volume of Big Data . Nevertheless, the widespread adoption of data-intensive processing is still limited by the non-trivial design paradigms involved, which deal with the unboundedness and volume of involved data streams and by the many distributed streaming platforms, each with its own characteristics and APIs. In this article, we present StreamGen, a Model-Driven Engineering tool to simplify the design of such streaming applications and automatically generate the corresponding code. StreamGen is able to automatically generate fully working and processing-ready code for different target platforms (e.g., Apache Spark, Apache Flink). Evaluation shows that (i) StreamGen is general enough to model and generate the code, offering comparable performance against a preexisting similar and well-known application; (ii) the tool is fully compliant with streaming concepts defined as part of the Google Dataflow Model; and (iii) users with little computer science background and limited experience with big data have been able to work with StreamGen and create/refactor an application in a matter of minutes.

Model-Driven Engineering Tools and Languages for Cyber-Physical Systems–A Systematic Literature Review

The development of Cyber-physical Systems (CPS) draws more interest from both researchers and industrial practitioners considering the opportunities they offer in almost all areas of industry. However, the engineering and management of CPS are challenging tasks due to their inherent heterogeneity and complexity characteristics. Regarding the development of CPS, there currently exists no standard methodology owing to the complexity of the domain. One of the key approaches to reduce the development complexity for CPS is Model-driven Engineering (MDE), which is frequently used in many industrial domains for software development to increase the level of platform abstraction. Nevertheless, it is always almost challenging, especially for the new researchers in this field, to determine the appropriate tools and languages to perform a particular MDE activity during CPS development. To the best of our knowledge, there is no guideline that demonstrates which language(s)/tool(s) to use for the various MDE techniques/phases for the development of CPS. This paper presents a Systematic Literature Review (SLR) study that focuses on identifying and classifying the recent research practices pertaining to CPS development by applying MDE approaches. With the objective of providing a general overview of the field, the study evaluates 140 research papers published during 2010–2018. Accordingly, a precise view of the various MDE tools and languages used in the development life-cycle of CPS, addressed MDE techniques/activities, and targeted CPS components is presented. We believe that the conducted study will guide researchers and practitioners to identify appropriate tools and languages according to the system requirements. It may also help in getting an overall understanding of the research trends for further research and development on the MDE of CPS.

IDFML: A Meta Language for Heterogeneous DSMLs Coordination

The popularization of both Software Language Engineering (SLE) and Model Driven Engineering (MDE) as well as the increasing complexity of systems induce new implementation practices. Indeed, many teams of experts collaborate to implement a same system. Every team uses her own domain specific modeling language (DSML) to represent her concerns. Consequently, by the end of the modelling phase, we get many heterogeneous models elaborated using different DSMLs. These models need to be composed to get a whole view of systems, to be able to validate and simulate behaviors. However, many recent researches choose to compose modelling languages rather than models themselves, but until now there are no standard or generic techniques for that. Although, MDE and SLE provide tools and concepts for modeling, customizing and processing business concepts as single activities, in contrast they provide little support for coordinating between these activities. In this paper, authors propose an interface-based approach to coordinate DSMLS in order to compose and coordinate their respective models. They began by giving generic guidelines of DSMLs specification and composition aspects. Then, they introduce IDFML a Meta language for defining both DSMLs interfaces and coordination. Actually, the proposed Meta language gives a metamodeling background to coordination which enables to benefit from MDE tools and techniques. They finally demonstrate the applicability of the approach using a Connected Indoor Transport Service System to conclude by summarizing benefits of the proposed Methodology.

Alliance of model-driven engineering with a proof-based formal approach

Model-driven engineering (MDE) promotes the use of models throughout the software development cycle in order to increase abstraction and reduce software complexity. It favors the definition of domain-specific modeling languages (DSMLs) thanks to frameworks dedicated to meta-modeling and code generation like EMF (Eclipse Modeling Framework). The standard semantics of meta-models allows interoperability between tools such as language analysers (e.g., XText), code generators (e.g., Acceleo), and also model transformation tools (e.g., ATL). However, a major limitation of MDE is the lack of formal reasoning tools allowing to ensure the correctness of models. Indeed, most of the verification activities offered by MDE tools are based on the verification of OCL constraints on instances of meta-models. However, these constraints mainly deal with structural properties of the model and often miss out its behavioral semantics. In this work, we propose to bridge the gap between MDE and the rigorous world of formal methods in order to guarantee the correctness of both structural and behavioral properties of the model. Our approach translates EMF meta-models into an equivalent formal B specification and then injects models into this specification. The equivalence between the resulting B specification and the original EMF model is kept by proven design steps leading to a rigorous MDE technique. The AtelierB prover is used to guarantee the correctness of the model’s behavior with respect to its invariant properties, and the ProB model-checker is used to animate underlying execution scenarios which are translated back to the initial EMF model. Besides the use of these automatic reasoning tools in MDE, proved B refinements are also investigated in this paper in order to gradually translate abstract EMF models to concrete models which can then be automatically compiled into a programming language.

A verified catalogue of OCL optimisations

OCL is widely used by model-driven engineering tools with different purposes like writing integrity constraints for meta-models, as a navigation language in model transformation languages or to define transformation specifications. Another scenario is the automatic generation of OCL code by a repair system. These generated expressions tend to be complex and unreadable due to the nature of the generative process. However, to be useful this code should be simple and resemble manually written code as much as possible when a developer must manually maintain it. There exists refactorings approaches for manually written OCL code, but there is no tool targeted to the optimisation of OCL expressions which have been automatically synthesised. Moreover, there is no available catalogue of OCL refactorings which can be integrated seamlessly into a tool. In this work, we contribute a set of refactorings intended to optimise OCL expressions, notably covering cases likely to arise in generated OCL code. We also contribute the implementation of these refactorings, built as a generic transformation catalogue using bentō, a transformation reuse tool for ATL. This makes it possible to specialise the catalogue for any OCL variant based on Ecore. Moreover, we propose a method to verify the correctness of the implemented catalogue based on translation validation and model finding. We describe the design and implementation of the catalogue and evaluate it by optimising a large amount of OCL expressions and proving the correctness of each optimisation execution. We also derive working implementations of the catalogue for ATL, EMF/OCL and SimpleOCL made available in a tool called BeautyOCL.

A Usability Model for Mobile Applications Generated with a Model-Driven Approach

Usability evaluation of mobile applications (referred to as apps) is an emerging research area in the field of Software Engineering. Several research studies have focused their interest on the challenge of usability evaluation in mobile context. Typically, the usability is measured once the mobile apps is implemented. At this stage of the development process, it is costly to go back and makes the required changes in the design in order to overcome usability problems. Model-driven Engineering (MDE) was proven as a promising solution for this problem. In such approach, a model can be build and analyzed early in the design cycle to identify key characteristics like usability. The traceability established between this model and the final application by means of model transformation plays a key role to preserve its usability or even improve it. This paper attempts to review existing usability studies and subsequently propose a usability model for conducting early usability evaluation for mobile apps generated with an MDE tool.

Improving user productivity in modeling tools by explicitly modeling workflows

Software engineering aims to create software tools that allow people to solve particular problems in an easy and efficient way. In this regard, model-driven engineering (MDE) enables to generate software tools, by systematically modeling and transforming models. To do so, MDE relies on language workbenches: Integrated Development Environment for engineering modeling languages, designing models, executing them, and verifying them. However, the usability of these tools is far from efficient. Common MDE activities, such as creating a domain-specific language or developing a model transformation, are non-trivial and often require repetitive tasks. This results in unnecessary risings of development time. The goal of this paper is to increase the productivity of modelers in their daily activities by automating the tasks performed in current MDE tools. We propose an MDE-based solution where the user defines a reusable workflow that can be parameterized at run-time and executed. We have implemented workflows in the graphical modeling tool AToMPM. An empirical evaluation shows that the users’ productivity is significantly improved.

Automated modelling assistance by integrating heterogeneous information sources

Model-Driven Engineering (MDE) uses models as its main assets in the software development process. The structure of a model is described through a meta-model. Even though modelling and meta-modelling are recurrent activities in MDE and a vast amount of MDE tools exist nowadays, they are tasks typically performed in an unassisted way. Usually, these tools cannot extract useful knowledge available in heterogeneous information sources like XML, RDF, CSV or other models and meta-models.We propose an approach to provide modelling and meta-modelling assistance. The approach gathers heterogeneous information sources in various technological spaces, and represents them uniformly in a common data model. This enables their uniform querying, by means of an extensible mechanism, which can make use of services, e.g., for synonym search and word sense analysis. The query results can then be easily incorporated into the (meta-)model being built. The approach has been realized in the Extremo tool, developed as an Eclipse plugin.Extremo has been validated in the context of two domains – production systems and process modelling – taking into account a large and complex industrial standard for classification and product description. Further validation results indicate that the integration of Extremo in various modelling environments can be achieved with low effort, and that the tool is able to handle information from most existing technological spaces.

Type inference in flexible model-driven engineering using classification algorithms

Flexible or bottom-up model-driven engineering (MDE) is an emerging approach to domain and systems modelling. Domain experts, who have detailed domain knowledge, typically lack the technical expertise to transfer this knowledge using traditional MDE tools. Flexible MDE approaches tackle this challenge by promoting the use of simple drawing tools to increase the involvement of domain experts in the language definition process. In such approaches, no metamodel is created upfront, but instead the process starts with the definition of example models that will be used to infer the metamodel. Pre-defined metamodels created by MDE experts may miss important concepts of the domain and thus restrict their expressiveness. However, the lack of a metamodel, that encodes the semantics of conforming models has some drawbacks, among others that of having models with elements that are unintentionally left untyped. In this paper, we propose the use of classification algorithms to help with the inference of such untyped elements. We evaluate the proposed approach in a number of random generated example models from various domains. The correct type prediction varies from 23 to 100% depending on the domain, the proportion of elements that were left untyped and the prediction algorithm used.

Model Driven Engineering (MDE) Tools: A Survey

Model Driven Engineering (MDE) is a new discipline in software engineering that advocates the massive use of models throughout the software development process. The emergence of this discipline has been accompanied by the prosperity of the tools that support it. On the long run, switching to MDE can be beneficial in case the process works, and the process itself depends on the tools. Since the transition is expensive, it is important to invest wisely, and choose the right tool. However, only recently tool creators have started considering metamodeling as an important issue in their list of concerns and university prototypes are sometimes difficult to download and test, so these tools remain little known overall and need to be listed. The aim of this article is to determine the strengths and weaknesses of the support that each of these MDE tools offer to the developer’s tasks, in order to learn to identify the right tool that meets the specific needs of the software engineer, without recommending any particular tool or vendors: It will present a significant number of the most popular MDE tools, in order to keep this paper simple, list some criteria for comparing these tools and evaluate them against those criteria.

An Approach to Checking Consistency between UML Class Model and Its Java Implementation

Model Driven Engineering (MDE) aims to expedite the software development process by providing support for transforming models to running systems. Many modeling tools provide forward engineering features, which automatically translate a model into a skeletal program that developers must complete. Inconsistencies between a design model and its implementation, however, can arise, particularly when a final implementation is developed dependently on the code from which it was generated. Manually checking that an implementation conforms to its model is a daunting task. Thus, an MDE tool that developers can use to check that implementations conform to their models can significantly improve a developer's productivity. This paper presents a model-based approach for testing whether or not an implementation satisfies the constraints imposed by its design model. Our model-based testing approach aims to efficiently reduce the test input space while supporting branch coverage criteria. To evaluate the approach's ability to uncover inconsistencies, we developed a prototypical tool and applied it to the Eclipse UML2 projects. We were able to uncover inconsistencies between the models and their implementations using the tool.

Efficient and scalable omniscient debugging for model transformations

This paper discusses a technique for supporting omniscient debugging for model transformations, which are used to define core operations on software and system models. Similar to software systems developed using general-purpose languages, model transformations are also subject to human error and may possess defects. Existing model-driven engineering tools provide stepwise execution to aid developers in locating and removing defects. In this paper, we describe our investigation into a technique and associated algorithms that support omniscient debugging features for model transformations. Omniscient debugging enables enhanced navigation and exploration features during a debugging session beyond those possible in a strictly stepwise execution environment. Finally, the execution time performance is comparatively evaluated against stepwise execution, and the scalability (in terms of memory usage) is empirically investigated.

Working with the HL7 metamodel in a Model Driven Engineering context

HL7 (Health Level 7) International is an organization that defines health information standards. Most HL7 domain information models have been designed according to a proprietary graphic language whose domain models are based on the HL7 metamodel. Many researchers have considered using HL7 in the MDE (Model-Driven Engineering) context. A limitation has been identified: all MDE tools support UML (Unified Modeling Language), which is a standard model language, but most do not support the HL7 proprietary model language. We want to support software engineers without HL7 experience, thus real-world problems would be modeled by them by defining system requirements in UML that are compliant with HL7 domain models transparently. The objective of the present research is to connect HL7 with software analysis using a generic model-based approach. This paper introduces a first approach to an HL7 MDE solution that considers the MIF (Model Interchange Format) metamodel proposed by HL7 by making use of a plug-in developed in the EA (Enterprise Architect) tool.

A taxonomy of tool-related issues affecting the adoption of model-driven engineering

Although poor tool support is often blamed for the low uptake of model-driven engineering (MDE), recent studies have shown that adoption problems are as likely to be down to social and organizational factors as with tooling issues. This article discusses the impact of tools on MDE adoption and practice and does so while placing tooling within a broader organizational context. The article revisits previous data on MDE use in industry (19 in-depth interviews with MDE practitioners) and reanalyzes that data through the specific lens of MDE tools in an attempt to identify and categorize the issues that users had with the tools they adopted. In addition, the article presents new data: 20 new interviews in two specific companies--and analyzes it through the same lens. A key contribution of the paper is a loose taxonomy of tool-related considerations, based on empirical industry data, which can be used to reflect on the tooling landscape as well as inform future research on MDE tools.