Eclipse Modeling Framework Research Articles

The Reverse Engineering of a Web Application Struts Based in the ADM Approach

Since web technologies are constantly evolving, the adaptation of legacy web applications to new paradigms such as rich internet applications (RIAs) is become a necessity. In such tendencies, we notice that several web leaders has already migrated their web applications to RIAs. However, it faces many challenges due to the variety of frameworks. Nevertheless, and in order to facilitate the process of migration, it would be ideal to use tools that could help automatically generate or ease the generation of UML (Unified Modeling Language) models from legacy web application. In this context, novel technical frameworks used for information integration and migration processes such as Architecture-Driven Modernization Task Force (ADMTF) were fashioned to describe specifications and promote industry accord on the modernization of existing applications. In this paper, we propose a process for migrating application from Struts to UML model using ADM standards and MoDisco. We then present a case study as an example illustrating the different steps of the proposed process. We then validated the proposition within Eclipse Modelling Framework since a number of its tools and run-time environments are indeed aligned with ADM standards.

Automatic Generation of Truffle-based Interpreters for Domain-Specific Languages.

Numerous language workbenches have been proposed over the past decade to ease the definition of Domain-Specific Languages (DSLs). Language workbenches enable language designers to specify DSLs using high-level metalanguages and to generate their implementation (e.g., parsers, interpreters) and tool support (e.g., editors, debuggers) automatically. However, little attention has been given to the performance of the resulting interpreters. In many domains where performance is key (e.g., scientific and high-performance computing), this forces language designer to hand-craft ad-hoc optimizations in the interpreter implementations, or to lose compatibility with tool support. In this paper, we propose to systematically exploit the domain-specific information of language specifications to derive optimized Truffle-based language interpreters executed over the GraalVM. We implement our approach on top of the Eclipse Modeling Framework (EMF) by complementing its existing compilation chain with Truffle-specific information, which drives the GraalVM to benefit from an optimized just-in-time compilation. A key benefit of our approach is that it leverages existing language specifications and does not require additional information from language designers who remain oblivious of Truffle's low-level intricacies and JIT optimizations in general while staying compatible with tool support. We evaluate our approach using a representative set of four DSLs and eight conforming programs. Compared to the standard interpreters generated by EMF running on the GraalVM, we observe an average speed-up of x1.14, ranging from x1.07 to x1.26. Although the benefits vary slightly from one DSL or program to another, we conclude that our approach yields substantial performance gains while remaining non-intrusive of EMF abstractions.

A Formalization Model Transformation Approach on Workflow Automatic Execution from CIM Level to PIM Level

Model transformation is a keystone in carrying out model-driven development. Currently, many studies have focused on model transformation, those researches study the automatic transformation from PIM to PSM and from PSM to code, but only few have dealt with how the CIM-level model is automatically mapped onto the PIM-level model. Even though some studies have proposed the semi-automatic transformation from CIM-level model to PIM-level model, only few mechanisms are discussed to protect the consistency between the CIM-level model and the PIM-level model in these researches because notation specification of these CIM-level model and PIM-level model does not contain precise semantics. Focusing on workflow perspective, this paper proposes an automatic model transformation approach, which applies a formal model to define the automatic mapping of the workflow from CIM-level model to PIM-level model. This proposal extends Petri nets model elements to define a bridge model, then we use this bridge model to link the CIM-level model (BPMN) and PIM-level model (SCM) following model-driven approach. The metamodels, the transformation rule and the transformation plug-ins have been defined in Eclipse Modeling Framework. Meanwhile, the plug-ins have been empirically validated by a Travel Agency case study. This study shows that using extended Petri nets model as a bridge model to define an automatic model transformation between CIM-level model and PIM-level model is feasible. This approach by means of formal model can ensure the correctness and completeness of the target model, and it can also maintain the consistency between the source model and target model.

Bridging proprietary modelling and open-source model management tools: the case of PTC Integrity Modeller and Epsilon

While the majority of research on Model-Based Software Engineering revolves around open-source modelling frameworks such as the Eclipse Modelling Framework, the use of commercial and closed-source modelling tools such as RSA, Rhapsody, MagicDraw and Enterprise Architect appears to be the norm in industry at present. This technical gap can prohibit industrial users from reaping the benefits of state-of-the-art research-based tools in their practice. In this paper, we discuss an attempt to bridge a proprietary UML modelling tool (PTC Integrity Modeller), which is used for model-based development of safety-critical systems at Rolls-Royce, with an open-source family of languages for automated model management (Epsilon). We present the architecture of our solution, the challenges we encountered in developing it, and a performance comparison against the tool’s built-in scripting interface. In addition, we use the bridge in a real-world industrial case study that involves the coordination with other bridges between proprietary tools and Epsilon.

Managing inter-model inconsistencies in model-based systems engineering: Application in automated production systems engineering

To cope with the challenge of managing the complexity of automated production systems, model-based approaches are applied increasingly. However, due to the multitude of different disciplines involved in automated production systems engineering, e.g., mechanical, electrical, and software engineering, several modeling languages are used within a project to describe the system from different perspectives. To ensure that the resulting system models are not contradictory, the necessity to continuously diagnose and handle inconsistencies within and in between models arises. This article proposes a comprehensive approach that allows stakeholders to specify, diagnose, and handle inconsistencies in model-based systems engineering. In particular, to explicitly capture the dependencies and consistency rules that must hold between the disparate engineering models, a dedicated graphical modeling language is proposed. By means of this language, stakeholders can specify, diagnose, and handle inconsistencies in the accompanying inconsistency management framework. The approach is implemented based on the Eclipse Modeling Framework (EMF) and evaluated based on a demonstrator project as well as a small user experiment. First findings indicate that the approach is expressive enough to capture typical dependencies and consistency rules in the automated production system domain and that it requires less effort compared to manually developing inter-model inconsistency management solutions.

An Open Source Domain-Specific Avionics System Architecture Model for the Design Phase and Self-Organizing Avionics

<div class="section abstract"><div class="htmlview paragraph">State-of-the-art avionics systems are standardized, e.g. the computing system of the flying vehicle is composed of pre-defined and pre-qualified modules of a standardized avionics platform. Integrated Modular Avionics (IMA) is the most popular representative, but not the only one. Two challenges of standardized avionics platform are system design and configuration. Since the high numbers of functions, modules, and constraints for modern air vehicles, bringing up the optimal system architecture is a difficult job if carried out manually. The subsequent process of creating millions of configuration parameters is time consuming and error prone. Both issues are similar and are, in general, processable by algorithms. Algorithms proved to provide significant support for current system design issues and might be mandatory in future, when avionics become self-organizing and the design and configuration are derived by the platform itself. Automated design already proved its advantages and self-organizing platforms started to be in development. Having the right and rigid data format for this purpose is mandatory. A suitable data format must hold all requirements necessary to proof the validity of the avionics architecture and take reliable organization decisions. It must be independent of technologies, in terms of hardware, software, and configuration. It must have a structure simple enough to be used in qualified embedded systems. Existing modeling approaches, e.g. AADL, have different purposes as detailed system design, dynamic simulations, virtual qualification, and lack especially rigidity and simplicity. The Open Avionics Architecture Model (OAAM) is a domain-specific model representing avionics system’s architectures designed to be used offline or online in the automated organization of avionics systems. It was implemented using the EMOF modeling standard and the Eclipse Modeling Framework (EMF). It is available as open source. This article explains the structure and the purpose of OAAM.</div></div>

Open meta-modelling frameworks via meta-object protocols

Meta-modelling is central to Model-Driven Engineering. Many meta-modelling notations, approaches and tools have been proposed along the years, which widely vary regarding their supported modelling features. However, current approaches tend to be closed and rigid with respect to the supported concepts and semantics. Moreover, extending the environment with features beyond those natively supported requires highly technical knowledge. This situation hampers flexibility and interoperability of meta-modelling environments.In order to alleviate this situation, we propose open meta-modelling frameworks, which can be extended and configured via meta-object protocols (MOPs). Such environments offer extension points on events like element instantiation, model loading or property access, and enable selecting particular model elements over which the extensions are to be executed. We show how MOP-based mechanisms permit extending meta-modelling frameworks in a flexible way, and allow describing a wide range of meta-modelling concepts. As a proof of concept, we show and compare an implementation in the MetaDepth tool and an aspect-based implementation atop the Eclipse Modelling Framework (EMF). We have evaluated our approach by extending EMF and MetaDepth with modelling services not foreseen initially when they were created. The evaluation shows that MOP-based mechanisms permit extending meta-modelling frameworks in a flexible way, and are powerful enough to support the specification of a broad variety of meta-modelling features.

Graph-Grammar-Based IP-Integration (GRIP)—An EDA Tool for Software-Defined SoCs

In modern system-on-chip (SoC) designs, IP-reuse is considered a driving force to increase productivity. To support various designs, a huge amount of Intellectual Property (IP) hardware blocks have been developed. The integration of those IPs into an SoC may require significant effort—up to days or weeks depending on experience and complexity. This article presents a novel approach to significantly reduce the design effort to bring-up a working SoC design by automatic IP integration as part of a library-based Software-defined SoC flow. In detail, the IP-supplier prepares a HW-accelerated software library (HASL) for the SoC architect, who wants to use the IP in an SoC design. As a key point of our approach, integration knowledge is encoded in the library as a set of integration rules. These rules are defined in the machine-readable standardized IP-XACT format by the IP supplier, who has a good knowledge of the IP’s hardware details. The library preparation step on the IP supplier’s side is also partly automated in the proposed flow, including a partial generation of configurable HW drivers, schedulers, and the software library functions. For the SoC architect, we have developed the graph-grammar-based IP-integration (GRIP) tool. The software application is developed using the functions supplied in the HASL. According to the calls to the HASL functions, the GRIP tool automatically integrates IP-blocks using the rule information supplied with the library and runs a full Design Space Exploration. For this, the SoC architecture and rules are transformed into the graph domain to apply graph rewriting methods. The GRIP tool is model-driven and based on the Eclipse Modeling Framework. With code generation techniques, SoC candidate architectures can be transformed to hardware descriptions for the target platform. The HW/SW interfaces between SW library functions and IP blocks can be automatically generated for bare-metal or Linux-based applications. The approach is demonstrated with two case-studies on the Xilinx Zynq-based ZedBoard evaluation board using a HASL for computer vision. It can yield 10×-150× performance improvement for the bare-metal application versions and 4×--7× performance improvement for the Linux-based application versions, when executed on an optimized HW-accelerated SoC architecture compared to a non HW-accelerated SoC. The effort for IP integration is comparable to using a software library, hence, providing a significant advantage over a manual IP integration.

Controlling Meta-Model Extensibility in Model-Driven Engineering

Model-driven engineering (MDE) considers the systematic use of models in software development. A model must be specified through a well-defined modeling language with precise syntax and semantics. In MDE, this syntax is defined by a meta-model. While meta-models tend to be fixed, there are several scenarios that require the customization of existing meta-models. For example, standards of the object management group (OMG) like the knowledge discovery meta-model (KDM) or the diagram definition (DD) are based on the extension of base meta-models according to certain rules. However, these rules are not “ operational ” but are described in natural language and therefore not supported by tools. Although modeling is an activity regulated by meta-models, currently there are no commonly accepted mechanisms to regulate how meta-models can be extended. Hence, in order to solve this problem, we propose a mechanism that allows specifying customization and extension rules for meta-models, as well as a tool that makes it possible to customize the meta-models according to such rules. The tool is based on the Eclipse modeling framework, has been implemented as an Eclipse plugin, and has been validated to guide the extension of OMG standard meta-models, such as KDM and DD.

SES and Ecore for Ontology-based Scenario Modeling in Aviation Scenario Definition Language (ASDL)

The Aviation Scenario Definition Language (ASDL) is a domain-specific language proposal which aims to provide a standard aviation scenario specification mechanism and enable the reuse of scenario generation methods among different simulators. This paper presents a model-based scenario development approach that exploits Eclipse Modeling Framework (EMF) core (Ecore) and System Entity Structure (SES) for metamodeling and modeling these elements. The construction of the ASDL metamodel using both platforms is described to illustrate the processes. As a result of comparing two approaches, it is concluded that they follow a similar structure in the hierarchical definition of modeled elements despite there being different toolsets available in each method. Thereby, each metamodel can be easily converted into the other type using transformations. As an application use case, the use of the proposed ontology-based scenario development in the aviation domain is discussed, where a training tool is being developed that utilizes SES/Ecore approach to build a scenario-driven training tool for air traffic controllers.

Model-based development of distributable user interfaces

The price drop of digital displays during the last decade has promoted the use of coupled-display ecosystems. This paper proposes a model-based approach to develop applications that exploit these ecosystems. It introduces the concept of Distributable User Interface to define applications running on coupled-display ecosystems that enable users to distribute interaction objects (e.g., labels, buttons, panels and frames) across interaction surfaces (e.g., Web documents, frames and panels) using a set of distribution primitives. The Distributable User Interface concept is formalized in the User Interface Distribution meta-model, which is implemented using the Eclipse Modeling Framework to ensure the compliance of these models with the OMG standards. This paper also describes the graphical model editor to create, edit and validate User Interface Distribution models conforming to the proposed meta-model. The models created with the model editor are used as input parameters for the model-to-text transformation developed in Acceleo that generates the source code of Web applications supporting Distributable User Interfaces. The generated code runs on the User Interface Distribution Framework which is also presented in this paper. Finally, the On-line Photo Gallery application is the case of study presented to demonstrate the viability of the proposal.

A Tool Support to Distributed Control Synthesis and Grafcet Implementation for Discrete Event Manufacturing Systems

Current production systems are becoming more complex: manufactured products are increasingly technical, production components are more specific, and control specifications are rapidly changing. Thus, formal methods and tools are becoming essential to support the automated development of control systems. We propose to develop a tool for the synthesis and implementation of modular/distributed supervisory control for Automated Manufacturing Systems (AMS). To reduce the computational complexity, we divide the control problem into local and global controls. Local Controllers (LCs) are designed for the individual subsystems, then global dependencies are added to the LCs to cooperatively execute the control actions. The tool provides a distributed control, interpreted as Grafcet (standard IEC 60848), that can be lately converted into any suitable IEC 61131-3 standard programming language for PLC programming purposes. It is based on Model-to-Model (M2M) transformations implemented in an Eclipse Modeling Framework (EMF) environment.

Extending Unified Modeling Language to Support Aspect-Oriented Software Development

Aspect-Oriented Software Development (AOSD) is continuously gaining more importance as the complexity of software systems increases and requirement changes are high- rated. A smart way for making reuse of functionality without additional effort is separating the functional and non functional requirements. Aspect-oriented software development supports the capability of separating requirements based on concerns. AspectJ is one of the aspect-oriented implementations of Java. Using Model Driven Architecture (MDA) specifications, an AspectJ model representing AspectJ elements can be created in an abstract way with the ability to be applied in UML, Java or XML. One of the open source tools which support MDA and follows the standards of the Object Management Group (OMG) for both UML and MDA is Eclipse providing an implementation of MDA through Eclipse Modeling Framework (EMF). This paper focuses on creating a UML profile; a UML extension which supports language specifications for AspectJ using EMF. Our work is based on the latest UML specification (UML 2.5) and uses MDA to enable the inclusion of aspect-oriented concepts in the design process.

Migrating C/C++ Software to Mobile Platforms in the ADM Context

Software technology is constantly evolving and therefore the development of applications requires adapting software components and applications in order to be aligned to new paradigms such as Pervasive Computing, Cloud Computing and Internet of Things. In particular, many desktop software components need to be migrated to mobile technologies. This migration faces many challenges due to the proliferation of different mobile platforms. Developers usually make applications tailored for each type of device expending time and effort. As a result, new programming languages are emerging to integrate the native behaviors of the different platforms targeted in development projects. In this direction, the Haxe language allows writing mobile applications that target all major mobile platforms. Novel technical frameworks for information integration and tool interoperability such as Architecture-Driven Modernization (ADM) proposed by the Object Management Group (OMG) can help to manage a huge diversity of mobile technologies. The Architecture-Driven Modernization Task Force (ADMTF) was formed to create specifications and promote industry consensus on the modernization of existing applications. In this work, we propose a migration process from C/C++ software to different mobile platforms that integrates ADM standards with Haxe. We exemplify the different steps of the process with a simple case study, the migration of “the Set of Mandelbrot” C++ application. The proposal was validated in Eclipse Modeling Framework considering that some of its tools and run-time environments are aligned with ADM standards.

A Model Driven Approach based on Interaction Flow Modeling Language to Generate Rich Internet Applications

<p><span lang="EN-US">A Rich Internet Applications (RIAs) combine the simplicity of the hypertext paradigm with the flexibility of desktop interfaces. These appliations were proposed as a solution to follow the rapid growth and evolution of the Graphical User Interfaces. However, RIAs are complex applications and their development requires designing and implementation which are time-consuming and the available tools are specialized in manual design. In this paper, we present a model driven approach to generat GUI for Rich Internet Application. The approach exploits the new language IFML recently adopted by the Object Management Group. We used frameworks and technologies known to Model-Driven Engineering, such as Eclipse Modeling Framework (EMF) for Meta-modeling, Query View Transformation (QVT) for model transformations and Acceleo for code generation. The approach allows to quickly and efficiently generating a RIA focusing on the graphical aspect of the application.</span></p>

Safe model polymorphism for flexible modeling

Domain-Specific Languages (DSLs) are increasingly used by domain experts to handle various concerns in systems and software development. To support this trend, the Model-Driven Engineering (MDE) community has developed advanced techniques for designing new DSLs. However, the widespread use of independently developed, and constantly evolving DSLs is hampered by the rigidity imposed to the language users by the DSLs and their tooling, e.g., for manipulating a model through various similar DSLs or successive versions of a given DSL. In this paper, we propose a disciplined approach that leverages type groups׳ polymorphism to provide an advanced type system for manipulating models, in a polymorphic way, through different DSL interfaces. A DSL interface, a.k.a. model type, specifies a set of features, or services, available on the model it types, and subtyping relations among these model types define the safe substitutions. This type system complements the Melange language workbench and is seamlessly integrated into the Eclipse Modeling Framework (EMF), hence providing structural interoperability and compatibility of models between EMF-based tools. We illustrate the validity and practicability of our approach by bridging safe interoperability between different semantic and syntactic variation points of a finite-state machine (FSM) language, as well as between successive versions of the Unified Modeling Language (UML).

Fine-Granular Model Merge Solution For Model-Based Version Control System

Software Configuration Management (SCM) aims to provide a controlling mechanism for the evolution of software artifacts created during software development process. Controlling software artifacts evolution requires many activities to be carried out such as, construction and creation of versions, computation of mappings and differences between versions, merging (i.e. combining of two or more versions) and so on. Traditional SCM systems are file-based SCM systems, which are not adequate for performing software configuration management activities. File-based SCM systems consider software artifacts as a set of text files, while today’s software development is model-driven and models are the main artifacts produced in the early phases of software development process. New challenges of model mappings, differencing, merging, and conflict detection arise when applying file-based solution to model-driven software. The goal of this paper is to develop a configuration management solution for model merging and conflict resolution that overcomes the challenges faced by traditional SCM systems for model-based development. We represent models at finegrained level as graph structures, which is an intermediate representation based on graph theory. Our approach follows a 3-way model merge process, where a base and its derived versions are used for comparison. To differentiate between conflicted and non-conflicted cases, we have defined different merge cases, and established a merge policy based on merge cases. Merge cases are used along with the comparison result in order to perform conflict resolution and merge operation. We performed a controlled experiment using open source eclipse modeling framework and compare our approach with an open source tool Eclipse Modeling Framework (EMF) Compare. The results proved the accuracy and efficiency of our proposed approach.

Embedded Systems Specific Requirements for Choreography Modelling Language Design

Software companies that develop embedded systems following the principles of service-oriented architecture can anticipate various benefits from choreography modelling. Current choreography modelling languages, however, have a limited applicability in embedded systems development since they are not expressive enough to capture all the choreography-relevant aspects that are typical in this domain. This problem is addressed in this study with the analysis of the needs in embedded systems domain for choreography modelling language. The analysis was guided by design science and relied on expert interviews, company-specific documents, relevant scientific literature and the experts' evaluation of the redesigned choreography modelling language. The main results of the analysis presented in this paper are a) design requirements addressing the limitations of choreography modelling languages for embedded systems development and b) proposals for modelling language implementation technologies. The derived design requirements indicate on choreography-relevant embedded systems development aspects such as the constraint-based access and real-time execution. Modelling language implementation technology proposals include Eclipse modelling framework and Sirius. The feasibility of these results is evaluated by redesigning an existing choreography modelling language based on the derived design requirements, implementing a prototype editor for the redesigned language and by evaluating the redesigned language with experts.

A Model Driven Approach for generating Graphical User Interface for MVC Rich Internet Application

<p><span style="font-size: 10.5pt; font-family: 'Times New Roman','serif'; mso-bidi-font-size: 12.0pt; mso-fareast-font-family: 宋体; mso-font-kerning: 1.0pt; mso-ansi-language: EN-US; mso-fareast-language: ZH-CN; mso-bidi-language: AR-SA;" lang="EN-US">Web applications have witnessed a significant improvement that exhibit advanced user interface behaviors and functionalities. Along with this evolution, Rich Internet Applications (RIAs) were proposed as a response to these necessities and have combined the richness and interactivity of desktop interfaces into the web distribution model. However, RIAs are complex applications and their development requires designing and implementation which are time-consuming and the available tools are specialized in manual design. In this paper, we present a new model driven approach in which we used well known Model-Driven Engineering (MDE) frameworks and technologies, such as Eclipse Modeling Framework (EMF), Graphical Modeling Framework (GMF), Query View Transformation (QVTo) and Acceleo to enable the design and the code automatic generation of the RIA. The method focus on simplifying the task for the designer and not necessary be aware of the implementation specification.</span></p>

Trustworthy variant derivation with translation validation for safety critical product lines

Software product line (SPL) engineering facilitates development of entire families of software products with systematic reuse. Model driven SPLs use models in the design and development process. In the safety critical domain, validation of models and testing of code increases the quality of the products altogether. However, to maintain this trustworthiness it is necessary to know that the SPL tools, which manipulate models and code to derive concrete product variants, do not introduce errors in the process.We propose a general technique of checking correctness of product derivation tools through translation validation. We demonstrate it using Featherweight VML—a core language for separate variability modeling relying on a single kind of variation point to define transformations of artifacts seen as object models. We use Featherweight VML with its semantics as a correctness specification for validating outputs of a variant derivation tool. We embed this specification in the theorem proving system Coq and develop an automatic generator of correctness proofs for translation results within Coq. We show that the correctness checking procedure is decidable, which allows the trustworthy proof checker of Coq to automatically verify runs of a variant derivation tool for correctness.We demonstrate how such a simple validation system can be constructed, by using this to validate variant derivation of a simple variability model implementation based on the Eclipse Modeling Framework. We hope that this presentation will encourage other researchers to use translation validation to validate more complex correctness properties in handling variability, as well as demonstrate to commercial tool vendors that formal verification can be introduced into their tools in a very lightweight manner.