Implementing the Unifying Meta-model for Enterprise Modeling and Model-Driven Development: An Experience Report

Model Driven Architectures and Model Driven Development (MDD) have been used in information system (IS) development projects for almost a decade. While the methodological support for the MDD process is important, the success of a project taking the model driven approach to development also heavily depends on the tool. The tool simply needs to support a set of key functionalities, such as an appropriate level of model abstraction, the refinement of models and finally the execution of models. In this paper we analyze a new MDD tool, namely Mendix, with respect to a number of functionality areas needed to achieve success in a project and capitalize on the benefits of MDD. Our findings are that Mendix use a well selected set of models and that these models are well integrated and suitable for the construction of small systems. Based on the key functionality areas we also point out the weaknesses of the tool.KeywordsModel Driven ArchitectureModel Driven DevelopmentMDDCASE tools

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.

Developing multi-purpose Human Language Technologies (HLT) pipelines and integrating them into the large scale software environments is a complex software engineering task. One needs to orchestrate a variety of new and legacy Natural Language Processing components, language models, linguistic and encyclopedic knowledge resources. This requires working with a variety of different APIs, data formats and knowledge models. In this paper, we propose to employ the Model Driven Development (MDD) approach to software engineering, which provides rich structural and behavioral modeling capabilities and solid software support for model transformation and code generation. These benefits help to increase development productivity and quality of HLT assets. We show how MDD techniques and tools facilitate working with different data formats, adapting to new languages and domains, managing UIMA type systems, and accessing the external knowledge bases.

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.

The usage of models within model-driven software development aims at facilitating complexity management of the system under development and closing the gap between the problem and the solution domain. Utilizing model-driven software development (MDD) tools for agile development can also increase the complexity within a project. The huge number of different artifacts and relations, their different kinds, and the high degree of automation hinder the understanding, maintenance, and evolution within MDD projects. A systematic approach to understand and manage MDD projects with a focus on its artifacts and corresponding relations is necessary to handle the complexity. The artifact-based analysis presented in this paper is such an approach. This paper gives an overview of different contributions of the artifact-based analysis but focuses on a specific kind of analysis: architecture consistency checking of model-driven development projects. By applying this kind of analyses, differences between the desired architecture and the actual architecture of the project at a specific point in time can be revealed.

In many development projects models are core artifacts used to generate concrete implementations from them. However, for many systems it is impossible or not useful to generate the complete software system from models alone. Hence, developers need mechanisms for integrating generated and handwritten code. Applying such mechanisms without considering their effects can cause issues in projects, where model and code artifacts are essential. Thus, a sound approach for the integration of both forms of code is needed. In this paper, we provide an overview of mechanisms for integrating handwritten and generated object-oriented code. To compare these mechanisms, we define and apply a set of criteria. The results are intended to help model-driven development (MDD) tool developers in choosing an appropriate integration mechanism. In this extended version, we additionally discuss essential integration aspects including the protection of generated code and elaborate on how to use action languages to extend generated code.

In order to resolve the problems of model-driven software development, a model-driven approach for the development of Web application system is proposed in this paper. The development process starts from describing of platform independent models. Then, mapping relations from the source model to the target model are built according to the syntactic structure and semantic features of both metamodels, and model transformation as well as code generation can be achieved subsequently. ASP.NET is used as a target platform in the experiment which shows that this approach follows the essence, process and requirements of model-driven software development, and thus can make an effect support for model driven software engineering.

The use of Model Driven Development (MDD) approach is increasing in industry. MDD approach raises the level of abstraction using models as main artifacts of software engineering processes. The development of model transformations is a critical step in MDD. Tasks for defining, specifying and maintaining model transformation rules can be complex in MDD. Model Transformation By Example (MTBE) approaches have been proposed to ease the development process of transformation rules. Starting from pairs of example models the transformation rules are derived semi-automatically.The aim of our approach is to derive the adaptation operations that must be implemented in a legacy model transformation to fulfill a new transformation requirement. An MTBE approach and a tool to develop and evolve ATL transformation rules have been developed. Our approach derives the transformations operations automatically using execution traceability data and models differences. The developed MTBE approach can be applied to evolve legacy model transformations. The tool can be used with endogenous and exogenous model to model transformations. The approach has been validated with several model transformations and the results have been collected. A real case study is introduced to demonstrate the usefulness of the tool.KeywordsModel driven developmentModel transformation developmentModel transformation by exampleModel transformation execution traceModel differences

In this paper we describe the main features of EMF Parsley, a new Eclipse project for implementing applications based on the Eclipse Modeling Framework (EMF). EMF Parsley aims at complementing the EMF reflective mechanisms with respect to rapidly creating user interfaces based on models, without having to deal with internal details and setup code. In particular, EMF Parsley uses injection mechanisms to easily customize all the aspects of such applications. Moreover, it provides a set of reusable user interface components like trees, tables and detail forms that manage the model with the introspective EMF capabilities, together with reusable views, editors and dialogs. Besides project wizards, to easily create projects based on EMF Parsley, the main developing tool is a DSL, implemented with Xtext/Xbase, that provides a rapid customization mechanism.

This chapter focuses on design methodologies for pervasive information systems (PIS). It aims to contribute to the efficiency and effectiveness of software development of ubiquitous services/applications supported on pervasive information systems. Pervasive information systems are comprised of conveniently orchestrated embedded or mobile computing devices that offer innovative ways to support existing and new business models. Those systems are characterized as having a potentially large number of interactive heterogeneous embedded/mobile computing devices that collect, process, and communicate information. Also, they are the target of technological innovations. Therefore, changes in requirements or in technology require frequent modifications of software at device and system levels. Software design and evolution for those require suitable approaches that consider such demands and characteristics of pervasive information systems. Model-driven development approaches (which essentially centre the focus of development on models, and involve concepts such as Platform-Independent Models, Platform-Specific Models, model transformations, and use of established standards) currently in research at academic and industrial arenas in the design of large systems, offer potential benefits that can be applied to the design and evolution of these pervasive information systems. In this chapter, we raise issues and propose strategies related to the software development of PIS using a model-driven development perspective.

Internet of Things (IoT) is being applied to areas as smart-cities, home environment, agriculture, industry, etc. Developing, deploying and testing IoT projects require high investments on devices, fog nodes, cloud nodes, analytic nodes, hardware and software. New projects require high investments on devices, fog nodes, cloud nodes, analytic nodes, hardware and software before each system can be developed. In addition, the systems should be developed to test them, which implies time, effort and development costs. However, in order to decrease the cost associated to develop and test the system the IoT system can be simulated. Thus, simulating environments help to model the system, reasoning about it, and take advantage of the knowledge obtained to optimize it. Designing IoT simulation environments has been tackled focusing on low level aspects such as networks, motes and so on more than focusing on the high level concepts related to IoT environments. Additionally, the simulation users require high IoT knowledge and usually programming capabilities in order to implement the IoT environment simulation. The concepts to manage in an IoT simulation includes the common layers of an IoT environment including Edge, Fog and Cloud computing and heterogeneous technology. Model-driven development is an emerging software engineering area which aims to develop the software systems from domain models which capture at high level the domain concepts and relationships, generating from them the software artefacts by using code-generators. In this paper, a model-driven development approach has been developed to define, generate code and deploy IoT systems simulation. This approach makes it possible to design complex IoT simulation environments and deploy them without writing code. To do this, a domain metamodel, a graphical concrete syntax and a model to text transformation have been developed. The IoT simulation environment generated from each model includes the sensors, actuators, fog nodes, cloud nodes and analytical characteristics, which are deployed as microservices and Docker containers and where elements are connected by using publish-subscribe communication protocol. Additionally, two case studies, focused on smart building and agriculture IoT environments, are presented to show the simulation expressiveness.

Conference proceedings front matter may contain various advertisements, welcome messages, committee or program information, and other miscellaneous conference information. This may in some cases also include the cover art, table of contents, copyright statements, title-page or half title-pages, blank pages, venue maps or other general information relating to the conference that was part of the original conference proceedings.

In real world, most business processes are subject to time constraints. Equally important as the execution of a process is the time in which it is to be performed. A time constrained business process can be defined as a process whose correct behavior depends not only on the results obtained, but also on the time it is carried out. UML has become an important tool for model-driven software development, perhaps partly thanks to its visually oriented modeling concepts, and it is increasingly being used in business process modeling too. In this paper, we extend UML 2.0 Activity Diagrams with time annotations and new modelling constructs inspired of the Timed CSP language. Furthermore, in order to overcome the lack of formal semantics that these diagrams suffer from, we introduce a set of mapping rules to derive formal specifications in terms of Timed CSP processes from models in the extended Activity Diagrams being proposed. Timed CSP has several features that make it well suited to give a formal semantics for extended Activity Diagrams (e.g., compositionality, well defined denotational and operational semantics, etc.). The proposed mapping rules enable checking whether the model described in an Activity Diagram satisfies such properties as timeliness, deadlock freeness, liveness, etc. In order to show the applicability of our approach, we present a case study from a manufacturing domain.

PurposeIn the last decade, web services have become a major technology to implement loosely coupled business processes and perform application integration. Through the use of context, a new generation of web services, namely context‐aware web services (CASs), is currently emerging as an important technology for building innovative context‐aware applications. Unfortunately, CASs are still difficult to build. Issues like lack of context provisioning management approach and lack of generic approach for formalizing the development process need to be solved in the first place for easy and effective development of CASs. The purpose of this paper is to investigate the techniques on developing CASs.Design/methodology/approachThe paper focuses on introducing a model‐driven platform, called ContextServ, and showcasing how to use this platform to rapidly develop a context‐aware web application, Smart Adelaide Guide. ContextServ adopts a model‐driven development (MDD) approach where a Unified Modeling Language (UML)‐based modeling language – ContextUML – is used to model web services and its context‐awareness features.FindingsThe paper presents novel techniques for efficient and effective development of CASs using a MDD approach. The ContextServ platform is the only one that provides a comprehensive software toolset that supports graphical modeling and automatic model transformation of CASs.Practical implicationsThe proposed approach has been validated in practice by developing various CASs. The experimental study demonstrates the efficiency and effectiveness of the approach.Originality/valueThe paper presents a novel platform called ContextServ, which offers a set of visual editing and automation tools for easy and fast generating and deploying CASs.

Most Eclipse projects which deal with modeling data are based on the Eclipse Modeling Framework (EMF) which provides code generation facilities for building tools and applications based on structured data models. However, from the user interface point of view, the development of applications based on EMF could be made simpler with more code reuse. For this reason, we propose EMF Components, a lightweight framework that allows easy and quick development of applications based on EMF. Besides providing a set of reusable components like trees, tables and detail forms that manage the model with the introspective EMF capabilities, EMF Components also comes with a DSL to make the configuration and customization of all the components much faster.KeywordsJava CodeJava ClassisEclipse Modeling FrameworkTree ViewerCode ReuseThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.