Model-driven Development Tools Research Articles

Edge IoT Prototyping Using Model-Driven Representations: A Use Case for Smart Agriculture.

Industry 4.0 is positioned at the junction of different disciplines, aiming to re-engineer processes and improve effectiveness and efficiency. It is taking over many industries whose traditional practices are being disrupted by advances in technology and inter-connectivity. In this context, enhanced agriculture systems incorporate new components that are capable of generating better decision making (humidity/temperature/soil sensors, drones for plague detection, smart irrigation, etc.) and also include novel processes for crop control (reproducible environmental conditions, proven strategies for water stress, etc.). At the same time, advances in model-driven development (MDD) simplify software development by introducing domain-specific abstractions of the code that makes application development feasible for domain experts who cannot code. XMDD (eXtreme MDD) makes this way to assemble software even more user-friendly and enables application domain experts who are not programmers to create complex solutions in a more straightforward way. Key to this approach is the introduction of high-level representations of domain-specific functionalities (called SIBs, service-independent building blocks) that encapsulate the programming code and their organisation in reusable libraries, and they are made available in the application development environment. This way, new domain-specific abstractions of the code become easily comprehensible and composable by domain experts. In this paper, we apply these concepts to a smart agriculture solution, producing a proof of concept for the new methodology in this application domain to be used as a portable demonstrator for MDD in IoT and agriculture in the Confirm Research Centre for Smart Manufacturing. Together with model-driven development tools, we leverage here the capabilities of the Nordic Thingy:53 as a multi-protocol IoT prototyping platform. It is an advanced sensing device that handles the data collection and distribution for decision making in the context of the agricultural system and supports edge computing. We demonstrate the importance of high-level abstraction when adopting a complex software development cycle within a multilayered heterogeneous IT ecosystem.

A Family of Experiments to Compare Two Model-Driven Development Tools vs a Traditional Development Method

<bold xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Context:</b> There are many papers which extol the benefits of Model-Driven Development (MDD) compared to traditional developments. However, the adoption of MDD to develop fully functional systems without coding is not frequent. <bold xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Objective:</b> This paper presents a family of experiments with 7 replications and 56 sample units to compare a traditional method versus MDD, analysing two MDD tools. <bold xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Method:</b> The factor in the experiment is the method with two treatments (traditional and MDD). We analyse together all replications thanks to two moderator variables in a multilevel hierarchy: Replication (from 1 to 7) and MDD Tool (INTEGRANOVA and WebRatio). Response variables are Functional Suitability, measured in terms of effectiveness in simple and complex problems; Effort, measured as time to develop simple problems; and Satisfaction, measured in terms of perceived ease of use, perceived usefulness and intention to use. <bold xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Result:</b> Functional Suitability in MDD yields significantly better results both in simple and complex problems, while Effort for simple problems is also significantly better for MDD. Differences for Functional Suitability in complex problems are greater than with simple ones. Considering the MDD tools, INTEGRANOVA yields significantly better Functional Suitability in complex problems. Regarding Satisfaction, replications with WebRatio have a better intention to use than replications with INTEGRANOVA. <bold xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Conclusions:</b> Even though MDD yields better Functional Suitability and Effort, the subjects’ Satisfaction with MDD is not better than with a traditional method.

Generation of Realistic Navigation Paths for Web Site Testing Using RNN and GAN

For applications that have not yet been launched, a reliable way for creating online navigation logs may be crucial, enabling developers to test their products as though they were being used by real users. This might lead to faster and lower-cost program testing and enhancement, especially in terms of usability and interaction. In this work we propose a method for using deep learning approaches such as recurrent neural networks (RNN) and generative adversarial neural networks (GANN) to produce high-quality weblogs. Eventually, we can utilize the created data for automated testing and improvement of Web sites prior to their release with the aid of model-driven development tools such as IFML Editor.

Models and methods of designing human-machine interaction-oriented interfaces

Formalization approaches of user interface design (UID) in conjunction with model driven techniques aim to improve the usability in terms of conformity to standards or style guides and to leverage code generation of interactive software systems, so that various UI platforms for web, desktop or mobile Applications are supported. Because large parts of the UI are described platform independent instead of platform dependent implementations, re-usability of the UI concept is also improved. However, UI formalization requires the usage of a formal UI description language and a higher level of abstractness compared to concrete UI code. These languages need to be learned by the UI designer. In practice, most parts of a user interface are still manually designed and coded individually for every platform. This paper describes how HCI (Human Computer Interface) patterns that are described formally can be used in conjunction with model-based user interface design in order to make it easier for the designer to use formalization techniques for the development of user interfaces. The approach uses two UML profiles: The MBUID (Model-Based User Interface Design) profile and the HCI pattern profile. With these profiles formal models of interactive systems can be created on a platform independent level. The user interface is then automatically generated by model-driven development tool chain.

On the benefits of file-level modularity for EMF models

Model-driven development (MDD) tools based on the Eclipse Modeling Framework (EMF) typically store all elements in a model in a single file which arguably is one of the main reasons why these tools do not scale well and cannot take advantage of existing code versioning systems and other related facilities such as Git and Make. In this work, we describe an approach for storing models in multiple files. We argue that EMF-based MDD tools can benefit significantly from this file-level modularity not only by improving the performance and scalability of basic model operations, but also by simplifying many model management activities through the use of existing code versioning systems and build automation tools. We introduce a domain-specific language that allows defining, at the metamodel level: (1) the mapping between models’ elements and the file structure for model storage and (2) the dependencies between model elements that affect the code generation and compilation (if the integration with code-based tools is required). Our suite then generates an API and scripts to provide support for file-level modularity and facilitate using code-based versioning and build tools. We have used our DSL in the context of Papyrus-RT, an MDD tool for real-time and embedded software, and show how file-level modularity can (1) substantially improve performance and scalability of load and save operations, (2) enable collaborative model development, and (3) facilitate MDD-specific activities such as model comparison and incremental code generation. Our implementation and the models used for evaluation are publicly available.

The Virtual Developer

Model Driven Development (MDD) requires proper tools to derive the implementation code from the application models. However, the integration of handwritten and generated code is a long-standing issue that affects the adoption of MDD in the industry. This article presents a model and code co-evolution approach that addresses such a problem a posteriori , using the standard collision detection capabilities of Version Control Systems to support the semi-automatic merge of the two types of code. We assess the proposed approach by contrasting it with the more traditional template-based, forward-engineering process, adopted by most MDD tools.

On the impact of state-based model-driven development on maintainability: a family of experiments using UniMod

Context: Model-driven approaches are well-known in the academia but one possible showstopper to a wider adoption in the industry is the limited empirical evidence for their claimed advantages and benefits, that could convince the decision makers. Objective: The aim of this work is gauging one of the claimed benefits of model-driven approaches, namely improvement in maintainability, with respect to a code-centric approach. Method: We conducted a family of five experiments involving 100 students that possessed different levels of education (64 Bachelor, 25 Master, and 11 PhD students; in groups sized 11 to 26 per individual experiment). In these experiments, UniMod – a State-based tool for Model-Driven Development using the Unified Modeling Language – is compared with Java-based code-centric programming, in a software maintenance scenario, with the goal of analyzing the effect on the time to perform the maintenance tasks, the correctness of the modified artifacts, and the efficiency. Results: The results show a reduction in time to accomplish the tasks and no impact on correctness. The adoption of the UniMod-MDD approach almost doubles the developers’efficiency, and in presence of a higher software engineering experience the efficiency is even three times higher. Conclusions: We found that the usage of the UniMod-MDD approach in a software maintenance scenario provides benefits over a pure code-centric approach. The benefits deriving from the UniMod-MDD approach are appreciable for all the categories of students, although with differences.

Heterogeneous Applications, Tools, and Methodologies in the Car Manufacturing Industry Through an IoT Approach

Due to the growth of industrial Internet services, today's production environment is on the edge of a new era of innovations and changes. This is taking place through the convergence of the global industrial system with the power of advanced computing, analytics, low-cost sensing, and new levels of connectivity enabled by the Internet of Things (IoT). These innovations will bring higher efficiency, flexibility, and interoperability among industries, although they belong to different production ecosystems. This paper describes an IoT platform and the related prototypes developed within the project: Enabling Business-Based Internet of Things and Services (ebbits), with a focus on the industrial domain. Heterogeneous applications were deployed and tested, including a wireless sensor and actuator network for industrial machines monitoring and a radio-frequency-identification-based system for operator management, locating, and authorization, which also includes an interactive user interface for portable devices to visualize real-time information from physical-world devices. Moreover, tools for model-driven development are used to simplify the process of building IoT applications. Those developments are based on IoT middleware that is developed and deployed by the project to enable the seamless integration of heterogeneous technologies and processes into mainstream enterprise systems. This paper also presents the prototypal deployment of the developed prototypes in the car manufacturing industry.

Combining Tools to Design and Develop Software Support for Capabilities

Analyzing, designing and implementing software systems based on the concept of capabilities have several benefits, such as the ability to design efficient monitoring of capabilities and their execution context. Today, there exist new model-driven methods and development tools that support capability-based analysis, design, and implementation. However, there are also a plethora of existing efficient development tools that are currently in use by organizations. In this article, we examine how a new set of capability based tools, the Capability Driven Development (CDD) environment, can be combined with model-driven development tools to leverage both novel capability-based functionality and the proven functionality of existing tools. We base the examination on a case study where an existing model-driven tool is combined with the CDD environment.

Extensible modeling with managed data in Java

Many model-driven development (MDD) tools employ specialized frameworks and modeling languages, and assume that the semantics of models is provided by some form of code generation. As a result, programming against models is cumbersome and does not integrate well with ordinary programming languages and IDEs. In this paper we present MD4J, a modeling approach for embedding metamodels directly in Java, using plain interfaces and annotations. The semantics is provided by data managers that create and manipulate models. This architecture enables two kinds of extensibility. First, the data managers can be changed or extended to obtain different base semantics of a model. This allows a kind of aspect-oriented programming. Second, the metamodels themselves can be extended with additional fields and methods to modularly enrich a modeling language. We illustrate our approach using the example of state machines, discuss the implementation, and evaluate it with two case-studies: the execution of UML activity diagrams and an aspect-oriented refactoring of JHotDraw.

ROSMOD: A Toolsuite for Modeling, Generating, Deploying, and Managing Distributed Real-time Component-based Software using ROS

This paper presents the Robot Operating System Model-driven development tool suite, (ROSMOD) an integrated development environment for rapid prototyping component-based software for the Robot Operating System (ROS) middleware. ROSMOD is well suited for the design, development and deployment of large-scale distributed applications on embedded devices. We present the various features of ROSMOD including the modeling language, the graphical user interface, code generators, and deployment infrastructure. We demonstrate the utility of this tool with a real-world case study: an Autonomous Ground Support Equipment (AGSE) robot that was designed and prototyped using ROSMOD for the NASA Student Launch competition, 2014–2015.

A model-based framework encompassing a complete workflow from specification until validation of timing requirements in embedded software systems

Embedded software engineering very often involves development of complex, mission critical software; wherein it is imperative that the developed software fulfills its requirements to achieve high quality. In such cases, there are several advantages of using specialized Requirements Management (RM) tools for managing the requirements. Critical timing requirements are among the foremost non-functional (quality) requirements to be fulfilled by increasingly complex embedded software. Further, a correct and effective timing behavior is among the characteristics of high-quality software. On the other hand, Model-Driven Development (MDD) is considered as the next paradigm shift to address the increasing complexity in embedded software development and to achieve high-quality standards. Similarly, there are specialized tools for validating and analyzing the timing behavior of the embedded software. However, such tools are used very late in the development process, when the actual timing errors occur. Thus, it is intuitive to perceive that an integrated model-based framework encompassing a complete workflow from specification until validation of timing requirements in embedded software systems is very beneficial for high-quality software development, nevertheless is still missing. Addressing the aforementioned gap, this paper proposes an approach toward a complete workflow for managing timing requirements in RM tools, specifying timing behavior in MDD tools and their validation in specialized tools for timing analyses. A prototype implementation of the proposed framework and its experimental evaluation are discussed.

Model-driven synthesis of formally precise, stylized software architectures

Abstract Reliably producing software architectures in selected architectural styles requires significant expertise yet remains difficult and error-prone. Our research goals are to better understand the nature of style-specific architectures, and relieve architects of the need to produce such architectures by hand. To achieve our goals, this paper introduces a formally precise approach to separate architectural style design decisions from application-specific decisions, and then uses these separate decisions as inputs to an automated synthesizer. This in effect supports a model-driven development (MDD) approach to architecture synthesis with style as a separate design variable. We claim that it is possible to formalize this separation of concerns, long implicit in software engineering research; to automatically synthesize style-specific architectures; and thereby to improve software design productivity and quality. To test these claims, we employed a combination of experimental systems and case study methods: we developed an MDD tool and used it to carry out case studies using Kitchenham’s methods. Our contributions include: a theoretical framework formalizing our separation of concerns and synthesis approach; an MDD framework, Monarch; and results of case studies that we interpret as supporting our claims. This work advances our understanding of software architectural style as a formal refinement; makes application descriptions an explicit subject of study; and suggests that synthesis of architectures can improve software productivity and quality.

Structured development of 3D applications: round-trip engineering in interdisciplinary teams

While structured software development processes are nowadays common-place, 3D applications are often still developed in an ad-hoc and code-centric manner. This state of affairs is somewhat surprising, as there are many benefits to a more structured 3D development process. In particular, model-based techniques with support for iterative development could help to ensure the mutual consistency of the code bases produced by the heterogeneous developer groups, i.e. 3D content developers and programmers. However, a cultural gap exists between 3D content developers and programmers who use completely different tools and terminologies. Common tools for model-driven development, for instance based on UML, are inadequate for the often "creatively oriented" 3D content developers. This paper presents a model-driven approach for the structured development of 3D applications in interdisciplinary teams based on round-trip engineering. Abstract models of the application are specified in SSIML, a DSL tailored for the development of 3D applications. In a forward phase, consistent skeletons of 3D scene models and program code are generated from the SSIML model. In a reverse phase, refinements of both the 3D scene model and program code are abstracted and synchronized to result in an updated SSIML model. This process is repeated in the subsequent iterations. Several examples of 3D application development on diverse platforms including Web, immersive virtual reality, and augmented reality on mobile devices demonstrate the versatility of our approach.

Translation rules of SysML state machine diagrams into CSP# toward formal model checking

Purpose – This study aims to describe the behavior of blocks in the system under consideration using systems modeling language (SysML) state machine diagrams. In this paper, formalization and model checking for SysML state machine diagrams have been investigated. Design/methodology/approach – The work by Zhang and Liu (2010) proposed a formalization of SysML state machine diagrams in which the diagrams were translated into CSP# processes that could be verified by the state-of-the-art model checker PAT. In this paper, several modifications have been made and new rules have been added to the translation described in that work. Findings – First, three translation rules were modified, which apparently are inappropriately defined according to the SysML definition of state machine diagrams. Next, we add new translation rules for two components of the diagrams – junction and choice pseudostates – which have not been dealt with previously. Further, we are implementing the automatic translation system on a web-based model-driven development tool, which reflects on our translation rules. Originality/value – As the contribution of this work, more reasonable verification results for more general SysML state machine diagrams can be achieved.

Verifying Protocol Conformance Using Software Model Checking for the Model-Driven Development of Embedded Systems

To facilitate modular development, the use of state machines has been proposed to specify the protocol (i.e., the sequence of messages) that each port of a component can engage in. The protocol conformance checking problem consists of determining whether the actual behavior of a component conforms to the protocol specifications on its ports. In this paper, we consider this problem in the context of the model-driven development (MDD) of embedded systems based on UML 2, in which UML 2 state machines are used to specify component behavior. We provide a definition of conformance which slightly extends those found in the literature and reduce the conformance check to a state space exploration. We describe a tool implementing the approach using the Java PathFinder software model checker and the MDD tool IBM Rational RoseRT, discuss its application to three case studies, and show how the tool repeatedly allowed us to find unexpected conformance errors with encouraging performance. We conclude that the approach is promising for supporting the modular development of embedded components in the context of industrial applications of MDD.

Design and evaluation of the ModelHealth toolchain for continuity of care web services

Motivation: Systems interoperability is a key challenge in providing continuity of care to all patients. The challenge is addressed with information standards and new approaches to systems integration based on service-oriented architectures. Model-driven development promise utilities that are suitable for software service development in the healthcare domain, but development tools are still immature and their industry uptake is low. The knowledge about how model-driven development tools can become more useful to the healthcare software developers should be strengthened. Approach: This paper presents the ModelHealth toolchain that was created in four design/assess cycles, involving 28 students and 41 professional developers in the period 2007---2010. The toolchain provides design assistance for creating software services based on concepts from the CEN-13940 standard for continuity of care, which facilitates development of interoperable software services. Results: The CEN-13940 standard was successfully incorporated into the ModelHealth Toolchain assisting developers in creating software service design models that adhered to the standard. The developers expressed that improved understanding of the target system, documentation generation, and artifact traceability were essential utilities of the model-driven approach. Conclusion: The paper concludes healthcare domain knowledge can be successfully incorporated in a model-driven development toolchain, providing valuable input to the healthcare software service design process. A set of recommendations on how to incorporate domain specific concepts into model-driven development tools is provided. To our knowledge, no other scientific publications have reported from healthcare specific model-driven tool design and evaluations. Our recommendations extend and nuance existing knowledge on model-driven development tooling in general.

Lessons learned from building model-driven development tools

Tools to support modelling in system and software engineering are widespread, and have reached a degree of maturity where their use and availability are accepted. Tools to support model-driven development (MDD)--where models are manipulated and managed throughout the system/software engineering lifecycle--have, over the last 10 years, seen much research and development attention. Over the last 10 years, we have had significant experience in the design, development and deployment of MDD tools in practical settings. In this paper, we distill some of the important lessons we have learned in developing and deploying two MDD tools: Epsilon and VIATRA. In doing so, we aim to identify some of the key principles of developing successful MDD tools, as well as some hints of the pitfalls and risks.

A framework for automated and certified refinement steps

The refinement calculus provides a methodology for transforming an abstract specification into a concrete implementation, by following a succession of refinement rules. These rules have been mechanized in theorem provers, thus providing a formal and rigorous way to prove that a given program refines another one. In a previous work, we have extended this mechanization for object-oriented programs, where the memory is represented as a graph, and we have integrated our approach within the rCOS tool, a model-driven software development tool providing a refinement language. Hence, for any refinement step, the tool automatically generates the corresponding proof obligations and the user can manually discharge them, using a provided library of refinement lemmas. In this work, we propose an approach to automate the search of possible refinement rules from a program to another, using the rewriting tool Maude. Each refinement rule in Maude is associated with the corresponding lemma in Isabelle, thus allowing the tool to automatically generate the Isabelle proof when a refinement rule can be automatically found. The user can add a new refinement rule by providing the corresponding Maude rule and Isabelle lemma.

Model-based approaches and frameworks for embedded software systems

Model-driven development (MDD) comprises approaches to software development that heavily rely on modeling and the systematic transition from models to executable code. One of these approaches is the OMG’s model-driven architecture (MDA), which is based on the separation between the specification of a system and its implementation using specific platforms. The workshop on Model-Based Methodologies for Pervasive and Embedded Software (MOMPES) focuses on all the aspects related to the adoption of MDA and other MDD approaches, including language, process, methods, and tools, for supporting the construction of computer-based systems, and more specifically, pervasive and embedded software systems. In this issue, we are happy to present the best papers from MOMPES 2009 and 2010. MOMPES 2009, the sixth in this series of workshops, took place during the 31st IEEE International Conference on Software Engineering (ICSE 2009) in Vancouver, Canada, on May 16. The seventh workshop, MOMPES 2010, was organized as a satellite event of the 25th IEEE/ACM International Conference on Automated Software Engineering (ASE 2010), which took place in Antwerp, Belgium, on September. The issue contains selected, extended, and revised versions of papers presented in these two workshops following a second round of rigorous review.