Model-driven Development Techniques Research Articles

Designing Reconfigurable Cyber-Physical Systems Using Unified Modeling Language

Technological progress in recent years in the Cyber-Physical Systems (CPSs) area has given designers unprecedented possibilities and computational power, but as a consequence, the modeled CPSs are becoming increasingly complex, hierarchical, and concurrent. Therefore, new methods of CPSs design (especially using abstract modeling) are needed. The paper presents an approach to the CPS control part modeling using state machine diagrams from Unified Modelling Language (UML). The proposed design method attempts to combine the advantages of graphical notation (intuitiveness, convenience, readability) with the benefits of text specification languages (unambiguity, precision, versatility). The UML specification is transformed using Model-Driven Development (MDD) techniques into an effective program in Hardware Description Language (HDL), using Concurrent Finite State Machine (CFSM) as a temporary model. The obtained HDL specification can be analyzed, validated, synthesized, and finally implemented in Field Programmable Gate Array (FPGA) devices. The dynamic, partial reconfiguration (a feature of modern FPGAs) allows for the exchange of a part of the implemented CPS algorithm without stopping the device. But to use this feature, the model must be safe, which in the proposed approach means, that it should possess special idle states, where the control is transferred during the reconfiguration process. Applying the CFSM model greatly facilitates this task. The proposed design method offers efficient graphical modeling of a control part of CPS, and automatic translation of the behavior model into a synthesizable Verilog description, which can be directly implemented in FPGA devices, and dynamically reconfigured as needed. A practical example illustrating the successive stages of the proposed method is also presented.

Developing Mobile Applications Via Model Driven Development: A Systematic Literature Review

Mobile applications (known as “apps”) usage continues to rapidly increase, with many new apps being developed and deployed. However, developing a mobile app is challenging due to its dependencies on devices, technologies, platforms, and deadlines to reach the market. One potential approach is to use Model Driven Development (MDD) techniques that simplify the app development process, reduce complexity, increase abstraction level, help achieve scalable solutions and maximize cost-effectiveness and productivity. This paper systematically investigates what MDD techniques and methodologies have been used to date to support mobile app development and how these techniques have been employed, to identify key benefits, limitations, gaps and future research potential. A Systematic Literature Review approach was used for this study based on a formal protocol. The rigorous search protocol identified a total of 1,042 peer-reviewed academic research papers from four major software engineering databases. These papers were subsequently filtered, and 55 high quality relevant studies were selected for analysis, synthesis, and reporting. We identified the popularity of different applied MDD approaches, supporting tools, artifacts, and evaluation techniques. Our analysis found that architecture, domain model, and code generation are the most crucial purposes in MDD-based app development. Three qualities – productivity, scalability and reliability – can benefit from these modeling strategies. We then summarize the key collective strengths, limitations, gaps from the studies and made several future recommendations. There has been a steady interest in MDD approaches applied to mobile app development over the years. This paper guides future researchers, developers, and stakeholders to improve app development techniques, ultimately that will help end-users in having more effective apps, especially when some recommendations are addressed, e.g., taking into account more human-centric aspects in app development.

Model-Driven AI for Games: Research Plan

The field of game AI is largely industry driven, lacking an agreed upon formalism for AI representation. Ad-hoc scripting languages, simple finite state machines, behaviour trees, and planners are employed, but not in a fashion adhering to any standard. As a result, reuse is sparse between games and formal analysis techniques are undeveloped. As research for a Ph.D. thesis, we propose to show that a layered Statechart-based AI is a suitable formalism for Game AI, enabling the use of model-driven development techniques such as reuse and high-level analysis including model-checking. The fundamentally modular nature of this approach leads naturally to reuse as a fundamental component of the design process. Supported by a clearly defined formalism, useful behavioural analyses become possible, such as testing reactions to various inputs at design time. We also explore transformations at the modelling level to enable procedural generation, allowing rapid deployment of varying AIs. Additionally, such a model allows for the generation of efficient code that can be directly inserted into games. Tool support for reuse, generation, and analysis will be developed, then employed in creating an industrial scale AI, proving that this formalism is appropriate for industrial use.

Integrating Provenance Capture and UML With UML2PROV: Principles and Experience

In response to the increasing calls for algorithmic accountability, UML2PROV is a novel approach to address the existing gap between application design, where models are described by UML diagrams, and provenance design, where generated provenance is meant to describe an application's flows of data, processes and responsibility, enabling greater accountability of this application. The originality of UML2PROV is that designers are allowed to follow their preferred software engineering methodology to create the UML Diagrams for their application, while UML2PROV takes the UML diagrams as a starting point to automatically generate: (1) the design of the provenance to be generated (expressed as <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">PROV templates</i> ); and (2) the software library for collecting runtime values of interest (encoded as variable-value associations known as <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">bindings</i> ), which can be deployed in the application without developer intervention. At runtime, the PROV templates combined with the bindings are used to generate high-quality provenance suitable for subsequent consumption. UML2PROV is rigorously defined by an extensive set of 17 patterns mapping UML diagrams to provenance templates, and is accompanied by a reference implementation based on Model Driven Development techniques. A systematic evaluation of UML2PROV uses quantitative data and qualitative arguments to show the benefits and trade-offs of applying UML2PROV for software engineers seeking to make applications provenance-aware. In particular, as the UML design drives both the design and capture of provenance, we discuss how the levels of detail in UML designs affect aspects such as provenance design generation, application instrumentation, provenance capability maintenance, storage and run-time overhead, and quality of the generated provenance. Some key lessons are learned such as: starting from a non-tailored UML design leads to the capture of more provenance than required to satisfy provenance requirements and therefore, increases the overhead unnecessarily; alternatively, if the UML design is tailored to focus on addressing provenance requirements, only relevant provenance gets to be collected, resulting in lower overheads.

Transformation of Alloy Notation into a Semantic Notation

Transformation of a model based on first-order logic to a model that provides semantic notations is helpful necessary during the analysis phase of any proposed software. The semantic notations often guide the designer to develop pseudocode correctly. This study focuses on facilitation of transformation of one formal model, i.e., Alloy into another, i.e., OWL. The proposed approach extends the concept of existing techniques i.e., UML2Alloy and TwoUse to transform Alloy model into OWL. UML2Alloy transforms UML model into Alloy model, whereas TwoUse approach bridges the gap between UML model and OWL model. Alloy2OWL is based on metamodel-based transformation techniques, which help to map source model, i.e., Alloy into target model, i.e., OWL. For the proper explanation of this study, a model transformation framework is presented, which can be applied to other transformation languages. The proposed approach utilizes the Model-Driven Development techniques to deal with the analysis of Alloy model and determines design problems within a specification. In this paper, various challenges are also presented which occur during the transformation of Alloy to OWL.

A tool-supported development method for improved BDI plan selection

Model-driven development (MDD) proposes the use of high-level abstractions to create models that describe concepts in a given domain, and a series of model-to-model and model-to-text transformations targeting several platforms. Many agent-oriented methodologies adopted such paradigm in the context of autonomous agents and multi-agent systems. Although the use of MDD takes from developers most of the development effort, there is still much left to them if we consider the need for adapting and providing agents with a sophisticated behaviour. Moreover, there is limited work evaluating the benefits provided by MDD in the context of agent-based systems. In this paper, we propose a tool-supported development method that applies MDD techniques to design and implement agents based on the belief-desire-intention architecture with a sophisticated plan selection process. We evaluated our approach with a user study, and results suggest that the use of our tool-supported development method can potentially ease the process of understanding and developing agent-based systems when facing them for the first time.

DREMS ML: A wide spectrum architecture design language for distributed computing platforms

Complex sensing, processing and control applications running on distributed platforms are difficult to design, develop, analyze, integrate, deploy and operate, especially if resource constraints, fault tolerance and security issues are to be addressed. While technology exists today for engineering distributed, real-time component-based applications, many problems remain unsolved by existing tools. Model-driven development techniques are powerful, but there are very few existing and complete tool chains that offer an end-to-end solution to developers, from design to deployment. There is a need for an integrated model-driven development environment that addresses all phases of application lifecycle including design, development, verification, analysis, integration, deployment, operation and maintenance, with supporting automation in every phase. Arguably, a centerpiece of such a model-driven environment is the modeling language. To that end, this paper presents a wide-spectrum architecture design language called DREMS ML that itself is an integrated collection of individual domain-specific sub-languages. We claim that the language promotes “correct-by-construction” software development and integration by supporting each individual phase of the application lifecycle. Using a case study, we demonstrate how the design of DREMS ML impacts the development of embedded systems.

Model-Driven Development of Automation and Control Applications: Modeling and Simulation of Control Sequences

The scope and responsibilities of control applications are increasing due to, for example, the emergence of industrial internet. To meet the challenge, model-driven development techniques have been in active research in the application domain. Simulations that have been traditionally used in the domain, however, have not yet been sufficiently integrated to model-driven control application development. In this paper, a model-driven development process that includes support for design-time simulations is complemented with support for simulating sequential control functions. The approach is implemented with open source tools and demonstrated by creating and simulating a control system model in closed-loop with a large and complex model of a paper industry process.

Reviewing Microgrids from a Multi-Agent Systems Perspective

The construction of Smart Grids leads to the main question of what kind of intelligence such grids require and how to build it. Some authors choose an agent based solution to realize this intelligence. However, there may be some misunderstandings in the way this technology is being applied. This paper exposes some considerations of this subject, focusing on the Microgrid level, and shows a practical example through INGENIAS methodology, which is a methodology for the development of Agent Oriented systems that applies Model Driven Development techniques to produce fully functional Multi-Agent Systems.

Model-driven specification and enforcement of RBAC break-glass policies for process-aware information systems

ContextIn many organizational environments critical tasks exist which – in exceptional cases such as an emergency – must be performed by a subject although he/she is usually not authorized to perform these tasks. Break-glass policies have been introduced as a sophisticated exception handling mechanism to resolve such situations. They enable certain subjects to break or override the standard access control policies of an information system in a controlled manner. ObjectiveIn the context of business process modeling a number of approaches exist that allow for the formal specification and modeling of process-related access control concepts. However, corresponding support for break-glass policies is still missing. In this paper, we aim at specifying a break-glass extension for process-related role-based access control (RBAC) models. MethodWe use model-driven development (MDD) techniques to provide an integrated, tool-supported approach for the definition and enforcement of break-glass policies in process-aware information systems. In particular, we provide modeling support on the computation independent model (CIM) layer as well as on the platform independent model (PIM) and platform specific model (PSM) layers. ResultsOur approach is generic in the sense that it can be used to extend process-aware information systems or process modeling languages with support for process-related RBAC and corresponding break-glass policies. Based on the formal CIM layer metamodel, we present a UML extension on the PIM layer that allows for the integrated modeling of processes and process-related break-glass policies via extended UML Activity diagrams. We evaluated our approach in a case study on real-world processes. Moreover, we implemented our approach at the PSM layer as an extension to the BusinessActivity library and runtime engine. ConclusionOur integrated modeling approach for process-related break-glass policies allows for specifying break-glass rules in process-aware information systems.

Semi-automated architectural abstraction specifications for supporting software evolution

In this paper we present an approach for supporting the semi-automated architectural abstraction of architectural models throughout the software life-cycle. It addresses the problem that the design and implementation of a software system often drift apart as software systems evolve, leading to architectural knowledge evaporation. Our approach provides concepts and tool support for the semi-automatic abstraction of architecture component and connector views from implemented systems and keeping the abstracted architecture models up-to-date during software evolution. In particular, we propose architecture abstraction concepts that are supported through a domain-specific language (DSL). Our main focus is on providing architectural abstraction specifications in the DSL that only need to be changed, if the architecture changes, but can tolerate non-architectural changes in the underlying source code. Once the software architect has defined an architectural abstraction in the DSL, we can automatically generate architectural component views from the source code using model-driven development (MDD) techniques and check whether architectural design constraints are fulfilled by these models. Our approach supports the automatic generation of traceability links between source code elements and architectural abstractions using MDD techniques to enable software architects to easily link between components and the source code elements that realize them. It enables software architects to compare different versions of the generated architectural component view with each other. We evaluate our research results by studying the evolution of architectural abstractions in different consecutive versions of five open source systems and by analyzing the performance of our approach in these cases.

A domain-specific language for context modeling in context-aware systems

Context-awareness refers to systems that can both sense and react based on their environment. One of the main difficulties that developers of context-aware systems must tackle is how to manage the needed context information. In this paper we present MLContext, a textual Domain-Specific Language (DSL) which is specially tailored for modeling context information. It has been implemented by applying Model-Driven Development (MDD) techniques to automatically generate software artifacts from context models. The MLContext abstract syntax has been defined as a metamodel, and model-to text transformations have been written to generate the desired software artifacts. The concrete syntax has been defined with the EMFText tool, which generates an editor and model injector.MLContext has been designed to provide a high-level abstraction, to be easy to learn, and to promote reuse of context models. A domain analysis has been applied to elicit the requirements and design choices to be taken into account in creating the DSL. As a proof of concept of the proposal, the generative approach has been applied to two different middleware platforms for context management.

A Model Driven Development Framework for Serious Games

Serious games have become more important in the field of education. The tight connection of education to computer game playing by presenting learning content in a game-like environment creates a better usage experience thus leading to higher usage and potentially better learning outcomes. To create successful serious games, it is necessary to combine programming knowledge and didactical knowledge to properly include learning objectives. Most educators are not able to develop such games on their own due to lack of programming and game design skills. In my dissertation, I am focusing on a solution based on model driven development techniques that shall allow educators to create didactically sound serious games. My idea is it to provide a domain specific modeling language for serious games and a visual modeling tool, which allows the generation of games from visual models.

Service-oriented computing and model-driven development as enablers of port information systems: an integrated view

Port information management is considered a critical instrument towards enabling international transport and trade; thus, various forms of Port Information Systems (PORTIS) have been developed today, namely Port Community Systems, Terminal Operating Systems and Single Window systems. In Europe, the nautical information system SafeSeaNet is viewed as an important e-infrastructure. PORTIS systems are expected to evolve into next-generation technological platforms in order to offer a fully integrated digital environment to a multitude of maritime business actors and public authorities towards more efficient, safe and environment-aware transport and trade infrastructures and services. We propose service-oriented computing and model-driven development techniques as a robust PORTIS modelling and development approach. We present a reference model of PORTIS and a particular enabling methodological and technological framework. The proposed approach has been tested in a maritime single-window case.

A Model-Driven Approach for the Design and Implementation of Software Development Methods

The Situational Method Engineering (SME) discipline emerged two decades ago to address the challenge of the in-house definition of software development methods and the construction of the corresponding supporting tools. Unfortunately, current SME approaches still have limitations that are hindering their adoption by industry. One of these limitations is that most approaches do not properly encompass two phases of the SME lifecycle, which refer to the method design and the method implementation. To address this limitation, this paper demonstrates how Model-Driven Development (MDD) techniques can contribute to successfully cover both phases. The proposal is illustrated by a real case study that is currently being used at the Valencian Regional Ministry of Infrastructure, Territory and Environment.

Extracting models from source code in software modernization

Model-driven software modernization is a discipline in which model-driven development (MDD) techniques are used in the modernization of legacy systems. When existing software artifacts are evolved, they must be transformed into models to apply MDD techniques such as model transformations. Since most modernization scenarios (e.g., application migration) involve dealing with code in general-purpose programming languages (GPL), the extraction of models from GPL code is an essential task in a model-based modernization process. This activity could be performed by tools to bridge grammarware and MDD technical spaces, which is normally carried out by dedicated parsers. Grammar-to-Model Transformation Language (Gra2MoL) is a domain-specific language (DSL) tailored to the extraction of models from GPL code. This DSL is actually a text-to-model transformation language which can be applied to any code conforming to a grammar. Gra2MoL aims to reduce the effort needed to implement grammarware-MDD bridges, since building dedicated parsers is a complex and time-consuming task. Like ATL and RubyTL languages, Gra2MoL incorporates the binding concept needed to write mappings between grammar elements and metamodel elements in a simple declarative style. The language also provides a powerful query language which eases the retrieval of scattered information in syntax trees. Moreover, it incorporates extensibility and grammar reuse mechanisms. This paper describes Gra2MoL in detail and includes a case study based on the application of the language in the extraction of models from Delphi code.

Development and evaluation of SOA-based AAL services in real-life environments: A case study and lessons learned

IntroThe proper use of ICT services can support seniors in living independently longer. While such services are starting to emerge, current proprietary solutions are often expensive, covering only isolated parts of seniors’ needs, and lack support for sharing information between services and between users. For developers, the challenge is that it is complex and time consuming to develop high quality, interoperable services, and new techniques are needed to simplify the development and reduce the development costs.This paper provides the complete view of the experiences gained in the MPOWER project with respect to using model-driven development (MDD) techniques for Service Oriented Architecture (SOA) system development in the Ambient Assisted Living (AAL) domain. MethodTo address this challenge, the approach of the European research project MPOWER (2006–2009) was to investigate and record the user needs, define a set of reusable software services based on these needs, and then implement pilot systems using these services. Further, a model-driven toolchain covering key development phases was developed to support software developers through this process. Evaluations were conducted both on the technical artefacts (methodology and tools), and on end user experience from using the pilot systems in trial sites. ResultsThe outcome of the work on the user needs is a knowledge base recorded as a Unified Modeling Language (UML) model. This comprehensive model describes actors, use cases, and features derived from these. The model further includes the design of a set of software services, including full trace information back to the features and use cases motivating their design. Based on the model, the services were implemented for use in Service Oriented Architecture (SOA) systems, and are publicly available as open source software. The services were successfully used in the realization of two pilot applications. There is therefore a direct and traceable link from the user needs of the elderly, through the service design knowledge base, to the service and pilot implementations.The evaluation of the SOA approach on the developers in the project revealed that SOA is useful with respect to job performance and quality. Furthermore, they think SOA is easy to use and support development of AAL applications. An important finding is that the developers clearly report that they intend to use SOA in the future, but not for all type of projects. With respect to using model-driven development in web services design and implementation, the developers reported that it was useful. However, it is important that the code generated from the models is correct if the full potential of MDD should be achieved.The pilots and their evaluation in the trial sites showed that the services of the platform are sufficient to create suitable systems for end users in the domain. ConclusionsA SOA platform with a set of reusable domain services is a suitable foundation for more rapid development and tailoring of assisted living systems covering reoccurring needs among elderly users. It is feasible to realize a tool-chain for model-driven development of SOA applications in the AAL domain, and such a tool-chain can be accepted and found useful by software developers.

Better Design Methods for eHealth Software

New software design and implementation methodologies are proposed in an attempt to overcome the high failure rate of eHealth projects. These new methodologies and architectures are based on Participatory Design principles, and Model Driven Development techniques. Their possible use is explained in the context of an example application in the coordination of treatment and wellness programs for the frail aged and chronically ill in community care settings.

Towards a Traceable Clinical Guidelines Application

The goal of this research is to provide an overall framework to enable model-based development of clinical guideline-based decision support systems (GBDSSs). The automatically generated GBDSSs are aimed at providing guided support to the physician during the application of guidelines and automatically storing guideline application data for traceability purposes. The development process of a GBDSS for a guideline is based on model-driven development (MDD) techniques which allow us to carry out such a process automatically, making development more agile and saving on human resource costs. We use UML Statecharts to represent the dynamics of guidelines and, based on this model, we use a MDD-based tool chain to generate the guideline-dependent components of each GBDSS in an automatic way. In particular, as for the traceability capabilities of each GBDSS, MDD techniques are combined with database schema mappings for metadata management in order to automatically generate the GBDSS-persistent component as one of the main contributions of this paper. The complete framework has been implemented as an Eclipse plug-in named GBDSSGenerator which, starting from the statechart representing a guideline, allows the development process to be carried out automatically by only selecting different menu options the plug-in provides. We have successfully validated our overall approach by generating the GBDSS for different types of clinical guidelines, even for laboratory guidelines. The proposed framework allows the development of clinical guideline-based decision support systems in an automatic way making this process more agile and saving on human resource costs.

A Model-Driven Development Approach to Mapping UML State Diagrams to Synthesizable VHDL

With the continuing rise in the complexity of embedded systems, there is an emerging need for a higher level modeling environment that facilitates efficient handling of this complexity. The aim here is to produce such a high-level environment using model- driven development (MDD) techniques that map a high-level abstract description of an electronic embedded system into its low-level implementation details. The Unified Modeling Language (UML) is a high-level graphical-based language that is broad enough in scope to model embedded systems hardware circuits. The authors have developed a framework for deriving very high speed integrated circuit hardware description language (VHDL) code from UML state diagrams and defined a set of rules that enable automated generation of synthesizable VHDL code from UML specifications using MDD techniques. By adopting the techniques and tools described in this paper, the design and implementation of complex state-based systems is greatly simplified.