Model-driven Development Approach Research Articles

Model-Driven Approach to develop Rich Web Applications

Many Web applications have among their features the possibility of distributing their data and their business logic between the client and the server, also allowing an asynchronous communication between them. These features, originally associated with the arrival of Rich Internet Applications (RIA), remain particularly relevant and desirable. In the area of RIA, there are few proposals that simultaneously consider these features, adopt Model-Driven Development (MDD), and use implementation technologies based on scripting. In this work, we start from MoWebA, an MDD approach to web application development, and we extend it by defining a specific architecture model with RIA functionalities, supporting the previously mentioned features. We have defined the necessary metamodels and UML profiles, as well as transformation rules that allow you to generate code based on HTML5, Javascript, jQuery, jQuery Datatables and jQuery UI. The preliminary validation of the proposal shows positive evidences regarding the effectiveness, efficiency and satisfaction of the users with respect to the modeling and code generation processes of the proposal.

Definition and evaluation of a COSMIC measurement procedure for sizing Web applications in a model-driven development environment

Context. Model-driven development approaches facilitate the production of Web applications. Among them, the Object-Oriented Hypermedia method (OO-H) has been successfully used for the development of industrial Web applications. Similarly to other development approaches, it is important also in this context to put measures in place to support project managers in resource allocation, cost and schedule control, and productivity monitoring.Objective. This motivated us to define a measurement procedure, named OO-HCFP, specifically conceived for OO-H Web applications based on COSMIC, a second-generation functional size measurement method.Method. We present mapping and measurement rules devised to automatically derive size measures from OO-H models. We also carry out an empirical study to evaluate whether our proposed measurement procedure, OO-HCFP, is useful for estimating the effort needed to realise industrial Web applications developed with OO-H.Results. The estimates obtained by using OO-HCFP are more accurate than those obtained by using other measurement approaches based on Function Points and design measures.Conclusions. The proposed approach can be profitably exploited to size Web applications developed with OO-H. Based on our experience, we also provide some guidelines to support the formulation of COSMIC measurement procedures for other model-driven approaches.

Agile and hierarchical round-trip engineering of IEC 61131-3 control software

The control software often performs complex, important, and responsible operations in industrial manufacturing systems. The size and complexity of such software are still increasing, thus it is important to provide engineers with methods and tools that simplify the development process. The situation can be improved by modeling using the Model-Driven Development (MDD) approach, standardized implementation process, as well as various testing methods. In the paper, the authors propose the further step, which consists of the comprehensive agile hierarchical round-trip engineering approach dedicated to the IEC 61131-3 control software. It divides the project into four connected parts – model, configuration, implementation, and tests. Such a solution allows developers to work independently and iteratively on various project parts, because changes are discovered automatically and are propagated to suitable views inside the project. The synchronization mechanism has been introduced into the CPDev engineering environment for programming industrial controllers.

Ontology-based framework for internal-external quality trade-offs and tenant management in multi-tenant applications

Software Quality Attributes (QAs) can be categorized as either internal to the system as experienced by the developers or external to the system perceived by the end users. These QA categories have trade-off among them - an emphasis on internal QA may result in a compromise of an external QA. For example, there is a trade-off between maintainability and performance. Model-driven development approaches manage this trade-off and increase the degree of internal QA maintainability. In this work, we propose an ontology-based communication mechanism among software components to handle the trade-off. The approach increases the degree of internal QAs such as modifiability, maintainability, testability during the design and development phases without compromising the external QAs for the end users during the operation phase. We also evaluate a prototype system to validate the proposed approach using Software Architecture Analysis Method (SAAM). It is also easier to integrate into the software development lifecycle as compared to existing model-driven approaches. The internal quality attributes become more significant in a multi-tenant scenario than conventional software. It requires managing dynamic requirements of tenants continuously. The proposed approach also useful in such scenario to reduce the maintenance overhead without compromising the degree of multi-tenancy.

UMIICA: A Model-Driven Integrated Development Environment for Industrial Control Applications

With the growing complexity of software-based industrial control applications, the demand for reliable software in the industrial control domain has also been increasing. Although the robustness of complex industrial control applications can benefit from formal modeling and verification, there remains a significant gap between formally verified models and real implementation. A model-driven development approach can be a solution to this problem. This paper aims to introduce a full-fledged model-driven integrated development environment, called UMIICA, for developing reliable industrial control applications. For this goal, we first determined the requirements imposed by the model-driven development process of networked industrial control applications. Based on these requirements, we analyzed the problems to be solved and designed the UMIICA tool according to the problem statements. Our proposed UMIICA tool is a full-fledged development environment for better productivity and software quality in our target application domain in that it incorporates whole model-driven development phases with cross-platform support and preserves the verified model behavior on the final implementation. As a case study, we constructed a three-axis cartesian robot testbed and developed an application for the testbed via the UMIICA tool. The evaluation results on our testbed also proved the effectiveness of UMIICA regarding the functional correctness and real-time performance guarantee of the resulting target application.

On Watermarking for Collaborative Model-Driven Engineering

Collaborative development scenarios often require models to be shared among the different stakeholders. These stakeholders are mostly remote with communication typically taking place over untrusted networks. This raises the need for effective intellectual property (IP) protection mechanisms for the shared models. Watermarking, an information hiding technique aimed at providing the means to verify the authenticity, integrity, and ownership of digital assets, has proved useful to provide IP protection in both media (images, audio, and video) and non-media domains (databases, XML documents, and graphs). In this paper, we explore the adaptation of the concept of watermarking to the modeling domain. We provide a novel and robust labeling mechanism based in the use of locality sensitive hashing and error correction codes. This labeling mechanism enables the integration of state-of-the-art watermarking algorithms in model-driven development approaches. Additionally, we leverage on the labeling mechanism to contribute a zero-watermarking algorithm to watermark models without introducing distortions to the data. We demonstrate the feasibility of our approach by providing a prototype implementation of our contribution.

Methodology for the model driven development of service oriented plant controls

In the age of the Industrial Internet of Things, distributed subsystems are established in many domains, which bring added value through their networking. In the field of industrial automation this means a distribution of the control system. As the distribution involves an increase in complexity, new approaches are needed that address this problem. This paper presents a model-driven development approach that involves a Service Oriented Architecture.

Model-driven agent-based simulation development: A modeling language and empirical evaluation in the adaptive traffic signal control domain

Model-driven development (MDD) is an approach for supporting the development of software systems, in which high-level modeling artifacts drive the production of time and effort-consuming low-level artifacts, such as the source code. Previous studies of the MDD effectiveness showed that it significantly increases development productivity, because the development effort is focused on the business domain rather than technical issues. However, MDD was exploited in the context of agent-based development in a limited way, and most of the existing proposals demonstrated the effectiveness of using MDD in this context by argumentation or examples, lacking disciplined empirical analyses. In this paper, we explore the use of MDD for agent-based modeling and simulation in the adaptive traffic signal control (ATSC) domain, in which autonomous agents are in charge of managing traffic light indicators to optimize traffic flow. We propose an MDD approach, composed of a modeling language and model-to-code transformations for producing runnable simulations automatically. In order to analyze the productivity gains of our MDD approach, we compared the amount of design and implementation artifacts produced using our approach and traditional simulation platforms. Results indicate that our approach reduces the workload to develop agent-based simulations in the ATSC domain.

A model-driven framework for developing multi-agent systems in emergency response environments

In emergency response environments, variant entities with specific behaviors and interaction between them form a complex system that can be well modeled by multi-agent systems. To build such complex systems, instead of writing the code from scratch, one can follow the model-driven development approach, which aims to generate software from design models automatically. To achieve this goal, two important prerequisites are: a domain-specific modeling language for designing an emergency response environment model, and transformation programs for automatic code generation from a model. In addition, for modeling with the language, a modeling tool is required, and for executing the generated code there is a need to a platform. In this paper, a model-driven framework for developing multi-agent systems in emergency response environments is provided which includes several items. A domain-specific modeling language as well as a modeling tool is developed for this domain. The language and the tool are called ERE-ML and ERE-ML Tool, respectively. Using the ERE-ML Tool, a designer can model an emergency response situation and then validate the model against the predefined constraints. Furthermore, several model to code transformations are defined for automatic multi-agent system code generation from an emergency response environment model. For executing the generated code, an extension of JAMDER platform is also provided. To evaluate our framework, several case studies including the Victorian bushfire disaster are modeled to show the ability of the framework in modeling real-world situations and automatic transformation of the model into the code.

Enterprise WAE: A Lightweight UML Extension for the Characterization of the Presentation Tier of Enterprise Applications with MDD-Based Mockup Generation

Nowadays, the Unified Modeling Language (UML) is the most successful notation for the design of object-oriented applications. However, plain UML is not enough to characterize the web presentation tier of enterprise applications, including the navigational, structural and role-based access control (RBAC) features present in these applications. In this paper, we present Enterprise Web Application Extension (E-WAE), a lightweight UML extension for the modeling of these elements, which permits the inclusion of multitier, Service-Oriented Architecture (SOA) and security design-level patterns in the models. Our approach follows a Model-Driven Development (MDD) approach, which enables the automatic generation of intermediate platform-specific models and automatic code generation for JavaServer Faces (JSF) and Active Server Pages.NET Model-View-Controller (ASP.NET MVC) frameworks. In addition, this generated code can be used as a low-cost mockup for early client validation of the navigational, structural and RBAC features of enterprise applications. E-WAE has been used with different applications. In this paper, we refer to the checkout process in the Amazon website, the delete resources use case in OdAJ2EE, an educational application developed by us, and the US Library of Congress Online Catalog search facility as examples of its applicability.

A Simple Software Rejuvenation Framework Based on Model Driven Development

In the current dynamic-natured business environment, it is inevitable that today’s software systems may not be suitable for tomorrow’s business challenges which indicate that the software in use has aged. Although we cannot prevent software aging, we can try to prolong the aging process of software so that it can be used for longer. In this paper, we outline a conceptual software rejuvenation framework based on model driven development approach. The framework is simple but effective and can be implemented in a recursive five step process. We have illustrated the applicability of the framework using a simple business case study which highlights the effectiveness of the framework. This work adds to the existing literature on software aging and its preventative measures. It also fills in the research gap which exists about software aging caused by changing requirements. Index Terms: Model Driven Development, Software Aging, Software Rejuvenation Framework

Towards fast metamodel evolution in LiquidML

The software industry is applying Model-driven development approaches due to a core set of benefits, such as raising the level of abstraction and reducing coding errors. However, their underlying modeling languages tend to be quite static, making their evolution hard, specifically when the corresponding metamodel does not support primitives and/or functionalities required in specific business domains. This paper presents an extension to the LiquidML language to support fast metamodel evolution by allowing experts to abstract new language concepts from primitives while supporting automatic tool evolution and zero application downtime. To probe our claims, we evaluate the evolutionary capabilities of existing modeling languages and LiquidML in a real world language extension.

Engineering Smart Grids: Applying Model-Driven Development from Use Case Design to Deployment

The rollout of smart grid solutions has already started and new methods are deployed to the power systems of today. However, complexity is still increasing as focus is moving from a single system, to a system of systems perspective. The results are increasing engineering efforts and escalating costs. For this reason, new and automated engineering methods are necessary. This paper addresses these needs with a rapid engineering methodology that covers the overall engineering process for smart grid applications—from use case design to deployment. Based on a model-driven development approach, the methodology consists of three main parts: use case modeling, code generation, and deployment. A domain-specific language is introduced supporting the use case design according to the Smart Grid Architecture Model. It is combined with the IEC 61499 distributed control model to improve the function layer design. After a completed use case design, executable code and communication configurations (e.g., IEC 61850) are generated and deployed onto compatible field devices. This paper covers the proposed rapid engineering methodology and a corresponding prototypical implementation which is validated in a laboratory experiment. Compared to other methods the proposed methodology decreases the number of engineering steps and reduces the use case design and implementation complexity.

Research on Augmenting the MDD Process with Variability Modeling

Software Product Lines (SPLs) have proven to be successful at reducing the costs and time to market of product development through the planned reuse of software components into products within the same scope. SPL adoption has been typically regarded to follow a proactive approach, although recent surveys show that most of the SPLs are planned following reactive approaches. It seems necessary to refocus SPL engineering research, methodologies and tools for existing systems into SPL. We believe that systems following a Model Driven Development (MDD) approach can highly benefit from these re-engineering efforts, in order to enable them to manage variability. The aim of this research is to analyze how to improve the MDD process with variability modeling in real industrial environments. Nowadays, we have performed three empirical studies related to variability modeling in MDD approaches. These studies are the following: (1) an usability evaluation of a MDD approach with variability modeling, (2) comprehensibility of variability in model fragments for product configuration and (3) an evaluation about bug-fixing in a MDD-SPL tool

Development of a web tool for action threshold evaluation in table grape pest management

Pest control is a major issue in agricultural management due to crop yield losses caused by pests. In this context, integrated pest management aims to suppress pest populations below an action threshold to minimize their impact. This paper presents the development of a web tool based on the Spanish regulations for the integrated pest management of table grapes; this provides decision support for evaluating when a particular pest action threshold has been crossed thus affecting table grape crops. The tool was built using a model-driven software development approach that enables software system generation from the problem’s knowledge model. The design of the knowledge bases which contain the system’s decision rules is also described. It is divided into knowledge bases that contain general knowledge related to the table grape crop as well as several specific knowledge bases (one per pest) containing the reasoning model that deduces the risk associated with a particular pest. The software has been designed by applying the model-driven development method thus making the system flexible, easy to evolve and adaptable whenever a new pest has to be incorporated into the software.

A framework for data transformation in Credit Behavioral Scoring applications based on Model Driven Development

The preprocessing stage in knowledge discovery projects is costly, normally taking between 50% and 80% of the total project time. It is in this stage that data in a relational database are transformed for applying a data mining technique. This stage is a complex task that demands from database designers a strong interaction with experts having a broad knowledge about the application domain. Frameworks aiming to systemize this stage have significant limitations when applied to Credit Behavioral Scoring solutions. This paper proposes a framework based on the Model Driven Development approach to systemize the mentioned stage. This work has three main contributions: 1) improving the discriminant power of data mining techniques by means of the construction of new input variables which embed temporal knowledge for the technique; 2) reducing the time of data transformation using automatic code generation, and 3) allowing artificial intelligence and statistics modelers to perform the data transformation without the help of database experts. In order to validate the proposed framework, two comparative studies were conducted. Experiments showed that the proposed framework delivers a performance equivalent or superior to those of existing frameworks and reduces the time of data transformation with a confidence level of 95%.

A model-driven development approach for context-aware systems

The widespread usage of various types of computer devices with different platform characteristics created a need for new methods and tools to support the development of context-aware applications capable of dynamically adapting themselves to context changes. In this paper, we present a new model-based approach that addresses the development of context-aware applications from both the theoretical and practical perspectives and that supports all development phases of context-aware systems. On the one hand, we describe how our approach is applied to dynamically capture, observe the change of the context and notify the system at runtime. On the other hand, we show how our approach is used by programmers to develop a context- aware application.

Model-driven development of mobile applications for Android and iOS supporting role-based app variability

Rapidly increasing numbers of applications and users make the development of mobile applications to one of the most promising fields in software engineering. Due to short time to market, differing platforms, and fast emerging technologies, mobile application development faces typical challenges where model-driven development (MDD) can help. We present a modeling language and an infrastructure for the MDD of native apps in Android and iOS. Our approach allows a flexible app development on different abstraction levels: compact modeling of standard app elements such as standard data management and increasingly detailed modeling of individual elements to cover, for example, specific behavior. Moreover, a kind of variability modeling is supported such that mobile apps with variants can be developed. We demonstrate our MDD approach with several apps including a conference app, a museum guide with augmented reality functionality, and a SmartPlug.

A pattern-based model-driven approach for situational method engineering

ContextConstructing bespoke software development methodologies for specific project situations has become a crucial need, giving rise to Situational Method Engineering (SME). Compared with Software Engineering, SME has a long way to go yet; SME approaches are especially deficient as to support for modeling, portability, and automation. Model-Driven Development (MDD) has been effectively used for addressing these issues in Software Engineering, and is also considered a promising approach for resolving them in SME. ObjectiveThis paper aims to address the shortcomings of existing SME approaches by introducing a novel MDD approach, specifically intended for SME purposes, that uses a pattern-based approach for model transformation. MethodDeveloping a MDD approach for SME requires that a modeling framework, consisting of modeling levels, be defined for modeling software development methodologies. Transformation patterns should also be specified for converting the models from one level to the next. A process should then be defined for applying the framework and transformations patterns to real SME projects. The resulting MDD approach requires proper evaluation to demonstrate its applicability. ResultsA framework and a semi-automated process have been proposed that adapt pattern-based model transformation techniques for application to the methodology models used in SME. The transformation patterns have been implemented in the Medini-QVT model transformation tool, along with two supplementary method bases: one for mapping the situational factors of SME projects to requirements, and the other for mapping the requirements to method fragments. The method engineer can produce the methodology models by using the method bases and executing the transformation patterns via the tool. ConclusionThe validity of the proposed approach has been assessed based on special evaluation criteria, and also through application to a real-world project. Evaluation results indicate that the proposed approach addresses the deficiencies of existing approaches, and satisfies the practicality requirements of SME approaches.

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.