nach oben

2018 | Buch

Kapitel lesen Erstes Kapitel lesen

Modelling Foundations and Applications

14th European Conference, ECMFA 2018, Held as Part of STAF 2018, Toulouse, France, June 26-28, 2018, Proceedings

herausgegeben von: Prof. Alfonso Pierantonio, Salvador Trujillo

Verlag: Springer International Publishing

Buchreihe : Lecture Notes in Computer Science

Enthalten in: Springer Professional "Wirtschaft+Technik" , Springer Professional "Technik" , Springer Professional "Wirtschaft"

Einloggen, um Zugang zu erhalten

Über dieses Buch

This book constitutes the proceedings of the 14th European Conference on Modelling Foundations and Applications, ECMFA 2018, held as part of STAF 2018, in Toulouse, France, in June 2018.
The 19 papers presented in this volume were carefully reviewed and selected from 45 submissions. The cover topics such as (bidirectional and unidirectional) model transformations, model management, re-engineering, modelling environments, verification and validation, and domain-specific modelling w.r.t. business processes, automotive software, and safety-critical software.

Inhaltsverzeichnis

Frontmatter

Is Bidirectionality Important?

Abstract

Bidirectional transformations maintain consistency between information sources, such as different models of the same software system. In certain settings this is undeniably convenient – but is it important? I will argue that developing our ability to engineer dependable bidirectional transformations is likely to be crucial to our ability to meet the demand for software in coming decades. I will discuss some of the work that has been done so far, including some I’ve had a hand in, and what challenges remain.

Perdita Stevens

Towards Automatic Generation of UML Profile Graphical Editors for Papyrus

Abstract

We present an approach for defining the abstract and concrete syntax of UML profiles and their equivalent Papyrus graphical editors using annotated Ecore metamodels, driven by automated model-to-model and model-to-text transformations. We compare our approach against manual UML profile specification and implementation using Archimate, a non-trivial enterprise modelling language, and we demonstrate the substantial productivity and maintainability benefits it delivers.

Athanasios Zolotas, Ran Wei, Simos Gerasimou, Horacio Hoyos Rodriguez, Dimitrios S. Kolovos, Richard F. Paige

Optimising OCL Synthesized Code

Abstract

OCL is a important element of many Model-Driven Engineering tools, used for different purposes like writing integrity constraints, as navigation language in model transformation languages or to define transformation specifications. There are refactorings approaches for manually written OCL code, but there is not any tool for the simplification of OCL expressions which have been automatically synthesized (e.g., by a repair system). These generated expressions tend to be complex and unreadable due to the nature of the generative process. However, to be useful this code should be as simple and resemble manually written code as much as possible.

In this work we contribute a set of refactorings intended to optimise OCL expressions, notably covering cases likely to arise in generated OCL code. We also contribute the implementation of these refactorings, built as a generic transformation component using bentō, a transformation reuse tool for ATL, so that it is possible to specialise the component for any OCL variant based on Ecore. We describe the design and implementation of the component and evaluate it by simplifying a large amount of OCL expressions generated automatically showing promising results. Moreover, we derive implementations for ATL, EMF/OCL and SimpleOCL.

Jesús Sánchez Cuadrado

Expressing Measurement Uncertainty in OCL/UML Datatypes

Abstract

Uncertainty is an inherent property of any measure or estimation performed in any physical setting, and therefore it needs to be considered when modeling systems that manage real data. Although several modeling languages permit the representation of measurement uncertainty for describing certain system attributes, these aspects are not normally incorporated into their type systems. Thus, operating with uncertain values and propagating uncertainty are normally cumbersome processes, difficult to achieve at the model level. This paper proposes an extension of OCL and UML datatypes to incorporate data uncertainty coming from physical measurements or user estimations into the models, along with the set of operations defined for the values of these types.

Manuel F. Bertoa, Nathalie Moreno, Gala Barquero, Loli Burgueño, Javier Troya, Antonio Vallecillo

On the Influence of Metamodel Design to Analyses and Transformations

Abstract

Metamodels are a central artifact of model-driven engineering. As they determine the structure of instance models, they are a foundation for other model-driven artifacts such as model transformations, code generators or model analyses. Therefore, the quality of metamodels is important for any model-driven process. However, the implications of metamodel design to other artifacts such as model analyses or model transformations has barely been looked at through empirical research. In this paper, we present an empirical study where we analyzed equivalent model analyses and transformations for 19 different metamodels of the same domain. The results indicate that metamodel design has a strong influence to model analysis in terms of code metrics but only little influence on model transformations targeting this metamodel.

Georg Hinkel, Erik Burger

Automatic Transformation Co-evolution Using Traceability Models and Graph Transformation

Abstract

In rule-based approaches, a model transformation definition tells how an instance of a source model should be transformed to an instance of a target model. As these models undergo changes, model transformations defined over these models may get out of sync. Restoring conformance between model transformations and the models is a complex and error prone task. In this paper, we propose a formal approach to automatically co-evolve model transformations according to the evolution of the models. The approach is based on encoding the model transformation definition as a traceability model and the evolution of the models as applications of graph transformation rules. These rules are used to obtain an evolved traceability model from the original traceability model. We will identify the criteria which need to be fulfilled in order to make this automatic co-evolution possible. We provide a tool support for this procedure, in which the evolved model transformation definition is derived from the evolved traceability model.

Adrian Rutle, Ludovico Iovino, Harald König, Zinovy Diskin

Bidirectional Method Patterns for Language Editor Migration

Abstract

Language editors play an important role in a Model-Driven Engineering context, as they enable the productive use of Domain Specific Languages (DSLs). To support language editor development, numerous language editor frameworks exist including extensible UML tools such as Enterprise Architect and textual language editor frameworks such as Xtext. When maintaining DSL-based software systems, language editor migration is an important task, which can be well supported with bidirectional transformation (bx) languages. There currently exists, however, no systematic guidelines describing why, when, and how bx languages can be leveraged for language editor migration. In this paper, therefore, we analyse the problem and solution domains for language editor migration, identifying and describing a set of reusable solution strategies that support assessing the potential and advantages of using bx languages in this context.

Enes Yigitbas, Anthony Anjorin, Erhan Leblebici, Marvin Grieger

Parallel Model Validation with Epsilon

Abstract

Traditional model management programs, such as transformations, often perform poorly when dealing with very large models. Although many such programs are inherently parallelisable, the execution engines of popular model management languages were not designed for concurrency. We propose a scalable data and rule-parallel solution for an established and feature-rich model validation language (EVL). We highlight the challenges encountered with retro-fitting concurrency support and our solutions to these challenges. We evaluate the correctness of our implementation through rigorous automated tests. Our results show up to linear performance improvements with more threads and larger models, with significantly faster execution compared to interpreted OCL.

Sina Madani, Dimitrios S. Kolovos, Richard F. Paige

SysML Models Verification and Validation in an Industrial Context: Challenges and Experimentation

Abstract

This paper presents a solution for SysML model verification and validation, with a return of experience from its implementation in an industrial context. We present this solution as a way to overcome issues regarding the use of SysML in an industrial context. We contribute by providing a method and a list of the existing challenges and experimentation results. We advocate the need to have semantics for SysML models without having to define a full domain-specific modeling language. We highlight the work, requirements and benefits that arise from the application of existing technical solutions, and hint at new perspectives and future development in system verification and validation.

Ronan Baduel, Mohammad Chami, Jean-Michel Bruel, Iulian Ober

Property-Aware Unit Testing of UML-RT Models in the Context of MDE

Abstract

Modern cyber-physical systems are complex to model due, among other things, to timing constraints and complex communications between components of such systems. Therefore, testing models of these systems is not straightforward. This paper presents an approach for automatically testing components of UML-RT models with respect to a set of formally defined properties. Compared to existing model-based techniques where abstract test cases are complemented with their concrete counterparts, our approach solely leverages on constructs provided by the modeling language to express all artifacts (component to test, test harness, the property of interest) and existing code generator to generate test cases. This helps to reduce the cost of ensuring the consistency between code- and model-level tests. Moreover, to reduce the number of test cases and the associated cost, our approach integrates our test case generators with slicing techniques to reduce the size of the components. A prototype implementation has been sketched and our approach has been evaluated over two case studies.

Reza Ahmadi, Nicolas Hili, Juergen Dingel

MAPLE: An Integrated Environment for Process Modelling and Enactment for NFV Systems

Abstract

The Network Functions Virtualization (NFV) paradigm is making way for the rapid provisioning of network services (NS). Defining a process for the design, deployment, and management of network services and automating it is therefore highly desirable and beneficial for NFV systems. The use of model-driven orchestration means has been recently advocated in this context. As part of this effort, we propose a process enactment approach with NFV systems as the target domain. We provide support for automated process execution with a megamodel-based enactment approach. An integrated process modelling and enactment environment, MAPLE, has been built into Papyrus for this purpose. Process modelling is carried out with UML activity diagrams. The enactment environment transforms the process model to a model transformation chain, and then orchestrates it with the use of megamodels. We demonstrate our environment by enacting a NS design process.

Sadaf Mustafiz, Guillaume Dupont, Ferhat Khendek, Maria Toeroe

Detecting Conflicts Between Data-Minimization and Security Requirements in Business Process Models

Abstract

Detecting conflicts between security and data-minimization requirements is a challenging task. Since such conflicts arise in the specific context of how the technical and organizational components of the target system interact with each other, their detection requires a thorough understanding of the underlying business processes. For example, a process may require anonymous execution for a task that writes data to a secure data storage, where the identity of the writer is needed for the purpose of accountability. To address this challenge, we propose an extension of the BPMN 2.0 business process modeling language to enable: (i) the specification of process-oriented data-minimization and security requirements, (ii) the detection of conflicts between these requirements based on a catalog of domain-independent anti-patterns. The considered security requirements were reused from SecBPMN2, a security-oriented extension of BPMN 2.0, while the data-minimization part is new. SecBPMN2 also provides a graphical query language called SecBPMN2-Q, which we extended to formulate our anti-patterns. We report on feasibility and usability of our approach based on a case study featuring a healthcare management system, and an experimental user study.

Qusai Ramadan, Daniel Strüber, Mattia Salnitri, Volker Riediger, Jan Jürjens

Life Sciences-Inspired Test Case Similarity Measures for Search-Based, FSM-Based Software Testing

Abstract

Researchers and practitioners alike have the intuition that test cases diversity is positively correlated to fault detection. Empirical results already show that some measurement of diversity within a pre-existing state-based test suite (i.e., a test suite not necessarily created to have diverse tests in the first place) indeed relates to fault detection. In this paper we show how our procedure, based on a genetic algorithm, to construct an entire (all-transition) adequate test suite with as diverse tests as possible fares in terms of fault detection. We experimentally compare on a case study nine different ways of computing test suite diversity, including measures already used by others in software testing as well as measures inspired by the notion of diversity in the life sciences. Although our results confirm a positive correlation between diversity and fault detection, we believe our results raise more questions than they answer about the notion and measurement of test suite diversity, which leads us to argue that more work needs to be dedicated to this topic.

Nesa Asoudeh, Yvan Labiche

EMF Patterns of Usage on GitHub

Abstract

Mining software repositories is a common activity in software engineering with diverse use cases such as understanding project quality, technology usage, and developer profiles. Such mining activities involve, more often than not, a phase for data extraction from the source code in the repository with recurring tasks such as processing the folder structure (possibly on the timeline), classifying repository artifacts (e.g., in terms of the languages or technologies used), and extracting facts from the artifacts by parsing or otherwise. We describe a new approach for such data extraction; its key pillar is a declarative rule-based language for the uniform, inference-based extraction of facts from the repository (the file system), the artifacts in the repository (their content), and previously extracted facts. All inferred facts are maintained in a triple store. We describe a case study for the purpose of understanding the usage of EMF. To this end, we describe an emerging catalog of patterns of using EMF in repositories and we detect these patterns on GitHub. In our implementation, we use Apache Jena for which we provide dedicated language support tailored towards mining software repositories.

Johannes Härtel, Marcel Heinz, Ralf Lämmel

Towards Efficient Loading of Change-Based Models

Abstract

This paper proposes and evaluates an efficient approach for loading models stored in a change-based format. The work builds on language-independent change-based persistence (CBP) of models conforming to object-oriented metamodelling architectures such as MOF and EMF, an approach which persists a model’s editing history rather than its current state. We evaluate the performance of the proposed loading approach and assess its impact on saving change-based models. Our results show that the proposed approach significantly improves loading times compared to the baseline CBP loading approach, and has a negligible impact on saving.

Alfa Yohannis, Horacio Hoyos Rodriguez, Fiona Polack, Dimitris Kolovos

Towards a Framework for Writing Executable Natural Language Rules

Abstract

The creation of domain-specific data validation rules is commonly performed by the relevant domain experts. Such experts are often not acquainted with the low-level technologies used to actually execute these rules and will hence document them in some informal form, such as in natural language. In order to execute these rules, they need to be transformed by technical experts into a relevant executable language, such as SQL. The technical experts in turn are often not familiar with the business logic these rules are depicting and will thusly have to collaborate with the business experts to gain insight into the semantics of the rules. This paper presents an approach for writing financial data validation rules in constrained natural language, that can then be automatically transformed and executed against the data they are referring to. In order to achieve this, we use the Xtext framework for creating the editor where business experts can create their rules that can then be transformed into executable constraints. We evaluate this approach in terms of its extensibility, coverage and verboseness with respect to the business rules sent to specific UK banks submitting data under one of the Bank of England’s annual reviews.

Konstantinos Barmpis, Dimitrios Kolovos, Justin Hingorani

Model-Driven Re-engineering of a Pressure Sensing System: An Experience Report

Abstract

This article presents our experience in re-engineering a pressure sensing system – a subsystem often found in safety-critical medical devices – using the B formal method. We evaluate strengths and limitations of the B method and its supporting platform Atelier B in this context. We find that the current state-of-the-art of model-oriented formal methods and associated tool-sets, especially in automatic code generation, requires further improvement to be amenable to a wider deployment to industrial applications for model-driven engineering purposes.

Atif Mashkoor, Felix Kossak, Miklós Biró, Alexander Egyed

Modeling AUTOSAR Implementations in Simulink

Abstract

AUTOSAR (AUTomotive Open System ARchitecture) is an open industry standard for the automotive sector. It defines the automotive three-layered software architecture. One layer is application layer, where functional behaviours are encapsulated in Software Components (SW-Cs). Inside SW-Cs, a set of runnable entities represent the internal behaviours and are realized as a set of tasks.To address AUTOSAR’s lack of support for modelling behaviours of runnables, other modelling languages such as Simulink are employed. Simulink simulations assume tasks are completed in zero execution time, while real executions require a finite execution time. This time mismatch can result in failures of analyzing an unexpected runtime behaviour during the simulation phase. This paper extends the Simulink environment to accommodate the timing relations of tasks during simulation. We present a Simulink block that can schedule tasks with a non-zero simulation time. This enables more realistic analysis during the model development stage.

Jian Chen, Manar H. Alalfi, Thomas R. Dean, S. Ramesh

Trace Comprehension Operators for Executable DSLs

Abstract

Recent approaches contribute facilities to breathe life into metamodels, thus making behavioral models directly executable. Such facilities are particularly helpful to better utilize a model over the time dimension, e.g., for early validation and verification. However, when even a small change is made to the model, to the language definition (e.g., semantic variation points), or to the external stimuli of an execution scenario, it remains difficult for a designer to grasp the impact of such a change on the resulting execution trace. This prevents accessible trade-off analysis and design-space exploration on behavioral models. In this paper, we propose a set of formally defined operators for analyzing execution traces. The operators include dynamic trace filtering, trace comparison with diff computation and visualization, and graph-based view extraction to analyze cycles. The operators are applied and validated on a demonstrative example that highlight their usefulness for the comprehension specific aspects of the underlying traces.

Dorian Leroy, Erwan Bousse, Anaël Megna, Benoit Combemale, Manuel Wimmer

Backmatter

Titel: Modelling Foundations and Applications
herausgegeben von: Prof. Alfonso Pierantonio
Salvador Trujillo
Verlag: Springer International Publishing
Electronic ISBN: 978-3-319-92997-2
Print ISBN: 978-3-319-92996-5
DOI: https://doi.org/10.1007/978-3-319-92997-2