Supporting Automatic Interoperability in Model-Driven Development Processes

By analyzing the last years of software development evolution, it is possible to observe that the involved technologies are increasingly focused on the definition of models for the specification of the intended software products. This model-centric development schema is the main ingredient for the Model-Driven Development (MDD) paradigm. In general terms, the MDD approaches propose the automatic generation of software products by means of the transformation of the defined models into the final program code. This transformation process is also known as model compilation process. Thus, MDD is oriented to reduce (or even eliminate) the hand-made programming, which is an error-prone and time-consuming task. Hence, models become the main actors of the MDD processes: the models are the new programming code. In this context, the interoperability can be considered a natural trend for the future of model-driven technologies, where different modeling approaches, tools, and standards can be integrated and coordinated to reduce the implementation and learning time of MDD solutions as well as to improve the quality of the final software products. However, there is a lack of approaches that provide a suitable solution to support the interoperability in MDD processes. Moreover, the proposals that define an interoperability framework for MDD processes are still in a theoretical space and are not aligned with current standards, interoperability approaches, and technologies. Thus, the main objective of this doctoral thesis is to develop an approach to achieve the interoperability in MDD processes. This interoperability approach is based on current metamodeling standards, modeling language customization mechanisms, and model-to-model transformation technologies. To achieve this objective, novel approaches have been defined to improve the integration of modeling languages, to obtain a suitable interchange of modeling information, and to perform automatic interoperability verification.Giachetti Herrera, GA. (2011). Supporting Automatic Interoperability in Model-Driven Development Processes [Tesis doctoral no publicada]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/11108Palanci

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

Verifying goal-oriented specifications used in model-driven development processes

[EN] Goal-oriented requirements engineering promotes the use of goals to elicit, elaborate, structure, specify, analyze, negotiate, document, and modify requirements. Thus, goal-oriented specifications are essential for capturing the objectives that the system to be developed should achieve. However, the application of goal oriented specifications into model-driven development (MDD) processes is still handcrafted, not aligned in the automated flow from models to code. In other words, the experience of analysts and designers is necessary to manually transform the input goal-oriented models into system models for code generation (models compilation). Some authors have proposed guidelines to facilitate and partially automate this translation, but there is a lack of techniques to assess the adequacy of goal-oriented models as starting point of MDD processes. In this paper, we present and evaluate a verification approach that guarantees the automatic, correct, and complete transformation of goal-oriented models into design models used by specific MDD solutions. In particular, this approach has been put into practice by adopting a well-known goal-oriented modeling approach, the i* framework, and an industrial MDD solution called Integranova.This work has been developed with the support of FONDECYT under the projects AMoDDI 11130583 and TESTMODE 11121395.This work is also supported by EOSSAC project, funded by the Ministry of Economy and Competitiveness of the Spanish government (TIN2013-44641-P).Giachetti Herrera, GA.; Marín, B.; López, L.; Franch, X.; Pastor López, O. (2017). Verifying goal-oriented specifications used in model-driven development processes. Information Systems. 64:41-62. https://doi.org/10.1016/j.is.2016.06.011S41626

Automatic Generation of Trace Links in Model-driven Software Development

Traceability data provides the knowledge on dependencies and logical relations existing amongst artefacts that are created during software development. In reasoning over traceability data, conclusions can be drawn to increase the quality of software. The paradigm of Model-driven Software Engineering (MDSD) promotes the generation of software out of models. The latter are specified through different modelling languages. In subsequent model transformations, these models are used to generate programming code automatically. Traceability data of the involved artefacts in a MDSD process can be used to increase the software quality in providing the necessary knowledge as described above. Existing traceability solutions in MDSD are based on the integral model mapping of transformation execution to generate traceability data. Yet, these solutions still entail a wide range of open challenges. One challenge is that the collected traceability data does not adhere to a unified formal definition, which leads to poorly integrated traceability data. This aggravates the reasoning over traceability data. Furthermore, these traceability solutions all depend on the existence of a transformation engine. However, not in all cases pertaining to MDSD can a transformation engine be accessed, while taking into account proprietary transformation engines, or manually implemented transformations. In these cases it is not possible to instrument the transformation engine for the sake of generating traceability data, resulting in a lack of traceability data. In this work, we address these shortcomings. In doing so, we propose a generic traceability framework for augmenting arbitrary transformation approaches with a traceability mechanism. To integrate traceability data from different transformation approaches, our approach features a methodology for augmentation possibilities based on a design pattern. The design pattern supplies the engineer with recommendations for designing the traceability mechanism and for modelling traceability data. Additionally, to provide a traceability mechanism for inaccessible transformation engines, we leverage parallel model matching to generate traceability data for arbitrary source and target models. This approach is based on a language-agnostic concept of three similarity measures for matching. To realise the similarity measures, we exploit metamodel matching techniques for graph-based model matching. Finally, we evaluate our approach according to a set of transformations from an SAP business application and the domain of MDSD

Computer-aided design for building multipurpose routing processes in discrete event simulation models

Good domain-modeling enables an appropriate separation of concerns that improves quality properties in the simulation models, such as modifiability and maintainability. In this paper, the interplay of abstraction and concreteness in advancing the theory and practice of Modelling and Simulation is improved using the Model-Driven Engineering levels for building simulation models devoted to routing processes. The definition of this type of processes is detailed as a domain-model conceived as an abstraction defined in a graph model. Such abstraction turns into a set of formal simulation models that are (later) translated into an executable implementation. The final simulation models are specified using Routed DEVS formalism. The methodological proposal is accomplished with the development of a Modelling and Simulation graphical software tool that uses the set of models (defined in terms of the Model-Driven Engineering approach) as the core of its operation. This graphical software tool is developed as a plug-in for Eclipse Integrated Development Environment with aims to take advantage of existent Modeling and Simulation software. Therefore, the usefulness of graphical modeling for supporting the development of the simulation models is empowered with a Model-Driven Engineering process. The main benefit obtained when the Model-Driven Engineering approach is used for modeling an abstraction of the final simulation model is a clear reduction of formalization and implementation times.Fil: Blas, María Julia. Consejo Nacional de Investigaciones Científicas y Técnicas. Centro Científico Tecnológico Conicet - Santa Fe. Instituto de Desarrollo y Diseño. Universidad Tecnológica Nacional. Facultad Regional Santa Fe. Instituto de Desarrollo y Diseño; ArgentinaFil: Gonnet, Silvio Miguel. Consejo Nacional de Investigaciones Científicas y Técnicas. Centro Científico Tecnológico Conicet - Santa Fe. Instituto de Desarrollo y Diseño. Universidad Tecnológica Nacional. Facultad Regional Santa Fe. Instituto de Desarrollo y Diseño; Argentin

Model-Driven Methodology for Rapid Deployment of Smart Spaces based on Resource-Oriented Architectures

Advances in electronics nowadays facilitate the design of smart spaces based on physical mash-ups of sensor and actuator devices. At the same time, software paradigms such as Internet of Things (IoT) and Web of Things (WoT) are motivating the creation of technology to support the development and deployment of web-enabled embedded sensor and actuator devices with two major objectives: (i) to integrate sensing and actuating functionalities into everyday objects, and (ii) to easily allow a diversity of devices to plug into the Internet. Currently, developers who are applying this Internet-oriented approach need to have solid understanding about specific platforms and web technologies. In order to alleviate this development process, this research proposes a Resource-Oriented and Ontology-Driven Development (ROOD) methodology based on the Model Driven Architecture (MDA). This methodology aims at enabling the development of smart spaces through a set of modeling tools and semantic technologies that support the definition of the smart space and the automatic generation of code at hardware level. ROOD feasibility is demonstrated by building an adaptive health monitoring service for a Smart Gym

Model driven configuration management

Model Driven Configuration Management (MDCM) ist ein neuartiger Ansatz, sowohl Konfigurationen als auch Architekturen der Softwareentwicklung durch gemeinsame Modelle darzustellen. Diese Modelle sollen dann als Input für Konfigurationsmanagement (CM) Tools und als Basis für die modellgetriebene Generierung von Code oder Konfigurationsdateien verwendet werden können. Durch die Verschmelzung von Konfigurationsmanagement und modellgetriebener Softwareentwicklung (MDSD) reicht das Zielpublikum dieser Arbeit von Konfigurations-Managern bis hin zu Software-Architekten und Entwicklern. Alle diese Rollen haben mit denselben Problemen zu kämpfen: Redundanz und die daraus entstehende Fehleranfälligkeit und Inkonsistenz beziehungsweise die dadurch zusätzlich anfallende Arbeit. MDCM verwendet allgemeine plattform-unabhängige Modelle, um ein System zu beschreiben. Aus diesen Modellen werden dann über Transformatoren detaillierte Modelle generiert. Dieses Vorgehen kennt man bereits vom MDSD. MDCM erweitert dieses Vorgehen um Modelle, die Konfigurationen beschreiben. Dadurch kann das allgemeine Modell sowohl als Basis für plattform-spezifische Modelle als auch für konfigurations-spezifische Modelle verwendet werden. Das Konfigurations-Modell beschreibt die Konfigurations-Einheiten und deren Beziehungen, während das plattform-spezifische Modell die Software-Komponenten und deren Verbindungen beschreibt. Der Model Driven Configuration Editor (MDCE) wurde im Rahmen dieser Arbeit entwickelt, um das Arbeiten mit und Generieren von Modellen zu vereinfachen. Der MDCE ermöglicht es, fertige Konfigurationen sowie das Grundgerüst von Applikationen zu generieren. Mit Hilfe von MDSD und auch des Editors soll die Zusammenarbeit zwischen Entwicklern/ Architekten und Konfigurations-Managern verbessert werden. Der Software Architekt soll dabei bei der Erstellung von Modellen unterstützt werden. Außerdem soll die Kommunikation zwischen Entwicklern und Konfigurations-Manager durch die einheitlichen Modelle verbessert werden. Letzterer profitiert außerdem von der Möglichkeit, aus den Modellen fertige Konfigurationen bzw. Input für CM Tools zu generieren. Kriterien für eine gute Lösung beinhalten die Verminderung von Redundanz im Entwicklungsprozess, ein Vorgehensmodell basierend auf der Idee von MDCM und durchgängigen, flexiblen und erweiterbaren Tool-Support für alle Arbeitsvorgänge. Diese Kriterien sollen durch folgende Entwicklungen erreicht werden: • MDCM - ein Konzept zur Verschmelzung von Konfigurations-Management und modellgetriebener Softwareentwicklung • ein Prozessmodell für MDCM • ein flexibler Ansatz bzw. ein Vorgehensmodell, einen Editor für MDCM zu entwickeln • der MDCE, ein Prototyp für Tool-Support des MDCM Prozesses.Model Driven Configuration Management (MDCM) deals with the concept of representing configurations and software development architectures using models based on common modeling languages like UML. These models can be used as an input for configuration management (CM) suites, as a foundation for an Model Driven Software Development (MDSD) workflow or to generate configuration files for different purposes. As a result of merging CM and MDSD, the target audience ranges from software developer to configuration manager. Even though there is a brief explanation of all used technologies, previous knowledge in CM, MDSD and UML will help to understand the covered topics. Each role mentioned above has to fight with the usual problems of software development: redundancy and error-proneness, inconsistency and the resulting higher amount of work. The main approach of MDCM is to use primary general models as a foundation for generating other more detailed models by using transformations. This procedure is also used by MDSD, but MDCM enhances this approach with models describing configurations. Based on a primary, platform independent model, a model for configurations and software development can be generated. The model for configuration management includes information on the configuration items and their relations and the model for software development defines the software components (classes, packages and methods). All the needed functionality like writing and transforming the models, is provided by the Model Driven Configuration Editor (MDCE), which is one big achievement of this work. It offers easy modelling of the configuration items and software components as well as the generation of models and application skeletons. This approach reduces redundancy and increases the cooperation between development and configuration management. MDCM and the editor support the software architect on creating the models for the development system and on coordinating those concepts with the configuration manager. The latter will benefit from the import of the configuration models to the CM suite provided by MDCE. And the software developer can use the code generation and MDSD functionality of MDCE to automatise parts of his work. Criteria for a good solution contain less redundancy, a procedure model for the development processes and tool support for all workflows, which should be easy to use and individually extendable. This work tries to accomplish these targets through the following achievements: • a concept for merging CM and MDSD called MDCM • a process model for MDCM • the model driven configuration editor MDCE • instructions how to create and enhance the MDC

A Novel Approach to Mutation Operator Design for MDE Languages

Due to the increasing reliance on the software of systems, such as enterprise systems, a wide array of approaches has been found to facilitate the development of software for such systems. The growth of system complexity, however, has provoked concerns about the quality of the software. One approach that copes with complexity is model driven engineering that uses models containing only essential domain concepts, in order to represent complex systems. With some level of automation, models are then maintained by programs that are prone to error, as they are man-made. In order to find errors in programs, software engineers use mutation testing to build strong test inputs by introducing faults into the tested software using mutation operators. They then study if the introduced faults are detected by the test inputs. There have been few attempts to design mutation operators for model driven languages, which have common metamodeling language models, compared with traditional programming languages. This thesis presents an effective language-agnostic approach for mutation operator design for the rapidly emerging model driven engineering languages by considering metamodeling languages. The approach produces generic operators that can be instantiated to generate concrete ones for a given language model, which can be used to mutate program models that conform to the language model. The approach and generic operators are evaluated using empirical mutation analysis experiments over programs written in the ATL and EOL languages. The results show that the generic operators generated from the approach are instantiatable over ATL and EOL metamodels and have produced low proportions of invalid and equivalent mutants that can impact negatively on any mutation testing process. Also, the generic operators have produced useful mutants such as live and not trivially detected kinds of mutants

Integration of Quality Attributes in Software Product Line Development

Different approaches for building modern software systems in complex and open environments have been proposed in the last few years. Some efforts try to apply Software Product Line (SPL) approach to take advantage of the massive reuse for producing software systems that share a common set of features. In general quality assurance is a crucial activity for success in software industry, but it is even more important when talking about Software Product Lines since the intensive reuse of assets makes the quality attributes (a measurable physical or abstract property of an entity) of the assets to be transmitted to the whole SPL scope. However, despite the importance that quality has in software product line development, most of the methodologies being applied in Software Product Line Development focus only on managing the commonalities and variability within the product line and not giving support to the non--¿ functional requirements that the products must fit. The main goal of this master final work is to introduce quality attributes in early stages of software product line development processes by means of the definition of a production plan that, on one hand, integrates quality as an additional view for describing the extension of the software product line and, on the other hand introduces the quality attributes as a decision factor during product configuration and when selecting among design alternatives. Our approach has been defined following the Model--¿ Driven Software Development paradigm. Therefore all the software artifacts defined had its correspondent metamodels and the processes defined rely on automated model transformations. Finally in order to illustrate the feasibility of the approach we have integrated the quality view in an SPL example in the context of safety critical embedded systems on the automotive domain.González Huerta, J. (2011). Integration of Quality Attributes in Software Product Line Development. http://hdl.handle.net/10251/15835Archivo delegad