MODELSWARD 2022 Abstracts

Area 1 - Applications and Software Development
Full Papers Short Papers
Area 2 - Methodologies, Processes and Platforms
Full Papers Short Papers
Area 3 - Modeling Languages, Tools and Architectures
Full Papers Short Papers

Area 1 - Applications and Software Development

Full Papers
Paper Nr: 22
Title:

Safety, Security and Performance Assessment of Security Countermeasures with SysML-Sec
Authors:

Bastien Sultan, Ludovic Apvrille and Philippe Jaillon
Abstract: Deploying security countermeasures on Cyber-Physical Systems (CPS) can induce side-effects that can exceed their benefits. When CPS are safety-critical systems, performing efficiency and impact assessments of security countermeasures early in the design flow is essential. The paper introduces the W-Sec method, based on SysML-Sec. The W-Sec method consists in two interwoven formal modeling and verification cycles aiming at providing countermeasures with objective and quantitative efficiency and impact assessments in terms of safety, security and performance. The paper evaluates the W-Sec method with an autonomous rover swarm case-study, and finally discusses the method’s strengths and weaknesses highlighted by the case-study results.
Download
Paper Nr: 60
Title:

Discerning Quantities from Units of Measurement
Authors:

Steve McKeever
Abstract: In scientific and engineering applications, physical quantities embodied as units of measurement (UoM) are frequently used. While managing units of measurement is a fairly mature topic in software engineering, more subtle metrological concepts such as named quantities have had little traction within the scientific programming community. The loss of the Mars climate orbiter, attributed to a confusion between the metric and imperial unit systems, popularised the disastrous consequences of incorrectly handling measurement values. This has led to the development of a large number of libraries, languages and tools to ensure developers can specify and validate UoM information in their designs and codes. However these systems do not differentiate between quantities and dimensions. For instance torque and work, which share the same UoM, can not be interchanged because they do not represent the same entity. We present a named quantity layer that sits on top of a dimension checker and unit converter ensuring values of different quantities are correctly managed without undue restrictions. Our quantity algebra works alongside the unit dimensions to ensure we maintain named quantities when we perform arithmetic and function calls.
Download
Paper Nr: 61
Title:

The Problem with ‘Dimensionless Quantities’
Authors:

B. D. Hall
Abstract: Many different quantities can be described as ‘dimensionless’ and have the same SI unit “one”, so their different natures cannot be determined from the unit name alone. In scientific unit systems like the SI, a set of base quantities and associated units can lead to such many-to-one relationships between quantities, dimensions, and units. So, it is necessary to understand how the mechanism of dimensions in unit systems works before trying to design more general formats for the expression of quantities. In the familiar expression of physical quantities, like mass, energy, etc, dimensions play a role when converting between unit systems or changing unit prefixes. So, it is often assumed that the notion of dimension is general. However, this paper explains that is not so: dimensions do not apply to all expressions of quantities. By recognising that there different types of measurement scale, the role played by dimensions in systems like the SI can be seen as secondary to the importance to the kind of quantity being expressed. There is a need to provide a unique way of identifying each kind of quantity: dimensions and unit names are not able to fulfil this requirement.
Download
Short Papers
Paper Nr: 29
Title:

Model-based Generation of Hazard-driven Arguments and Formal Verification Evidence for Assurance Cases
Authors:

Fang Yan, Simon Foster, Ibrahim Habli and Ran Wei
Abstract: Assurance cases (ACs) are an established practice for arguing confidence in critical system properties such as safety and security in high-risk industries. ACs use system artifacts to argue the aforementioned properties. Due to the iterative nature of system development, we need to update ACs to maintain assurance validity as a system evolves. For example, a changed design or an added hazard would result in re-evaluation of claims or a new claim to be verified. Thus, the generation and maintenance of ACs is a labour-intensive process. With the growing application of Model-based Engineering (MBE) in system development, it is beneficial to generate ACs from design models because this captures traceability, and enables automatic AC creation and update driven by model modification. Accordingly, the contribution of this paper is an automatic approach to AC generation and assembly from both unstructured design artifacts and UML-like design models within Eclipse. This approach also supports AC evidence generation by formal verification facilitated by automatically generated assertions. The realization of AC assembly and verification is supported by model query and model transformation. We apply our approach to an autonomous underwater robot with the RoboChart robotics modelling language.
Download
Paper Nr: 35
Title:

Model-driven Engineering and Simulation of Industrial Robots with ROS
Authors:

Niels Hoppe and Jan Hoffschulte
Abstract: Industrial automation is the earliest and best established application of robotics. Today, however, increasing complexity of industrial robotics applications places high demands on system integrators. In order to make this complexity more manageable, we developed a model-driven engineering approach for the modular composition and simulation of complex ensembles of industrial robots based on the Robot Operating System (ROS). The approach consists of a domain-specific profile for the Unified Modeling Language (UML) and a model-to-text transformation for automatic generation of artifacts required for control and simulation. The modelling methodology and code generation were successfully applied to a use case example which is also described in the paper.
Download
Paper Nr: 37
Title:

Automated Curation of Variational Data in NoSQL Databases through Metric-driven Self-adaptive Migration Strategies
Authors:

Andrea Hillenbrand and Uta Störl
Abstract: Schema-flexible NoSQL databases have become popular backends in agile development. They allow developers to write code flexibly while assuming a new database schema different from the current one. The co-evolution of the schema with the software code, together with requirements for performance and cost efficiency, require subtle management decisions regarding the migration of variational legacy data persisted in the production database. Project managers have to deal with the consequences of schema evolution in order to comply with service-level agreements, especially if metrics specified in the SLAs compete with each other in tradeoffs. We present self-adaptive schema migration strategies that curate just as much variational data so that competing metrics can be balanced out, thus making continuous management interventions superfluous.
Download
Paper Nr: 47
Title:

Towards Model-driven Fuzzification of Adaptive Systems Specification
Authors:

Tomáš Bureš, Petr Hnětynka, Martin Kruliš and Jan Pacovský
Abstract: The position paper outlines a method transforming adaptation rules in a self-adaptive system to a machine learning problem using neural networks. This makes it possible to endow a self-adaptive system with the possibility to learn. At the same time, by controlling the degree to which this transformation is done, one can scale the tradeoff between learning capacity and uncertainty in the self-adaptive system. The paper elaborates this process as a model transformation pipeline. The pipeline starts with a model capturing the strict adaptation rules. Then it is followed by multiple steps in which the strict rules are gradually fuzzified by well-defined transformations. The last model transformation in the pipeline transforms the fuzzified rules to a neural network that can be trained using the traditional stochastic gradient descent method. We briefly showcase this using two examples from the area of collective adaptive systems.
Download
Paper Nr: 55
Title:

UgameFeature: Automatic Code Generation for Unity Game Projects
Authors:

Joshua Kritz, Mart de Roos, Luís F. Pires, João R. Moreira and Giancarlo Guizzardi
Abstract: Computer games are complex software systems, which means that their development requires some level of programming skills. However, their design also involves the creation of game objects (characters, scenarios, etc.), animations and story lines, which are designed by game domain experts, who in general have minimal (or no) programming skills. Game engines have been developed to facilitate game development by reducing programming efforts and enhancing productivity, but we observed that most of these engines still require programming skills in order to be used. In this paper, we discuss how Model-Driven Engineering technologies, particularly metamodelling and model transformations, can be used to facilitate game development. We define a Domain Specific Language called UGameFeature to be used by game designers to define games that can be automatically transformed into scripts that can be executed by the Unity game engine. In order to facilitate the code generation step, we defined an intermediate metamodel, so that structural differences between the UGameFeature metamodel and the Unity engine scripts can be accommodated by an intermediate model-to-model transformation. We claim that with this approach we could define a streamlined process to go from game design to game implementation, in this way surpassing the benefits already offered by game engines. We also discuss some practical obstacles of applying MDE techniques and give recommendations to practitioners who want to apply them in their projects.
Download
Paper Nr: 2
Title:

Text-To-Model (TeToMo) Transformation Framework to Support Requirements Analysis and Modeling
Authors:

Gayane Sedrakyan, Asad Abdi, Stéphanie M. Van Den Berg, Bernard Veldkamp and Jos Van Hillegersberg
Abstract: Requirements analysis and modeling is a challenging task involving complex knowledge of the domain to be engineered, modeling notation, modelling knowledge, etc. When constructing architectural artefacts experts rely largely on the tacit knowledge that they have built based on previous experiences. Such implicit knowledge is difficult to teach to novices, and the cost of the gap between classroom knowledge and real business situations is thus reflected in further needs for post-graduate extensive trainings for novice and junior analysts. This research aims to explore the state-of-the art natural language processing techniques that can be adopted in the domain of requirements engineering to assist novices in their task of knowledge construction when learning requirements analysis and modeling. The outcome includes a method called Text-To-Model (TeToMo) that combines the state-of-the-art natural language processing approaches and techniques for identifying potential architecture element candidates out of textual descriptions (business requirements). A subsequent prototype is implemented that can assist a knowledge construction process through (semi-) automatic generation and validation of Unified Modeling Lnaguage (UML) models. In addition, to the best of our knowledge, a method that integrates machine learning based method has not been thoroughly studied for solving requirements analysis and modeling problem. The results of this study suggest that integrating machine learning methods, word embedding, heuristic rules, statistical and linguistic knowledge can result in increased number of automated detection of model constructs and thus also better semantic quality of outcome models.
Download
Paper Nr: 39
Title:

Automatic Code Generation for a Seamless Low-cost Development Platform
Authors:

Sven Jacobitz and Xiaobo Liu-Henke
Abstract: The automatic generation of Electronic Control Units (ECU) software from functional models is becoming an increasingly important part of the development process. At first, this paper presents the demand towards a tool chain for functional development of embedded systems and then introduces the low-cost development platform LoRra on the basis of the seamless model-based rapid control prototyping development process. The core of the paper is the conception and realization of the automatic code generator of the LoRra platform. It generates modular, flexibly usable C code, suitable for real-time implementation on a microcontroller. The code is generated from models of the open source CAE software Scilab / Xcos, which can be used across domains. A simple case study is used to verify the function of the generated code under real-time conditions.
Download
Paper Nr: 45
Title:

Towards a Lightweight Model-driven Smart-city Digital Twin
Authors:

Jean-Sébastien Sottet, Pierre Brimont, Christophe Feltus, Benjamin Gateau and Jean-Francois Merche
Abstract: In this article we consider the use of digital twin for representing open physical system, notably smart-cities. In this context everything is not necessarily defined or sensed; as a result a pure data-driven approach is not possible and should be completed by expert knowledge, hence through models. We propose an approach to design a model-driven digital twins MDDT that supports this context. It allows to 1/ quickly prototype digital twins, 2/ integrate various information from different kind of sources (diverse expertise, data, etc.) 3/ support evolution and enhancement all along the system’s life-cycle.
Download
Paper Nr: 57
Title:

Model to Hardware: System-level Modeling for Wearable Devices
Authors:

Daniela Genius and Roselyne Chotin
Abstract: Wearable devices which capture and analyze physiological data in a non-invasive and not restraining manner are increasingly popular, but usually employ specialized hardware. Software is often limited, specific, and expensive. This paper shows how system-level modeling, virtual prototyping and electronic design can interact to help designing low-cost wearable bio-medical devices. We propose a design method which allows validation against actual electronic/mechanical prototypes and present a first case study, a daytime sleepiness detector.
Download

Area 2 - Methodologies, Processes and Platforms

Full Papers
Paper Nr: 59
Title:

MDD4REST: Model-Driven Methodology for Developing RESTful Web Services
Authors:

Amirhossein Deljouyi and Raman Ramsin
Abstract: Web services based on the REpresentational State Transfer (REST) architectural style have become increasingly popular in recent years. REST provides several desirable features, such as simplicity and scalability; however, developing RESTful web services involves repetitive and trivial tasks that can be avoided through automatic code generation. Model-Driven Development (MDD) can be used to this aim, as it facilitates the construction of complex applications and can provide automatic code generation through transformations of models. This paper presents MDD4REST as a model-driven methodology, consisting of a framework and a process, for developing RESTful web services. MDD4REST takes advantage of Domain-Driven Design (DDD) to produce a rich domain model for web services. It provides an effective method for designing RESTful web services using modeling languages, and supports automatic code generation through transformation of models. In addition, MDD4REST has the capability to support modern web architectures and patterns, such as Microservice, Event-Driven, and CQRS.
Download
Short Papers
Paper Nr: 3
Title:

Transforming Domain Specific Modeling Languages into Feature Models
Authors:

Maouaheb Belarbi and Vincent Englebert
Abstract: This paper proposes a methodology for software factory design guided by DSMLs (Domain Specific Modeling Languages) in the context of the SPL (Software Product Line) area. In order to guide the engineer in the design of the generative process, we propose a transformation allowing to transform the annotated metamodel of a DSML into an Feature Model that can be used later as a decision tree to help the engineer in the choice of the best implementation tactics for the variants. The article presents and illustrates the transformation based on an industrial example.
Download
Paper Nr: 5
Title:

Semi-automatic Integrated Safety and Security Analysis for Automotive Systems
Authors:

Markus Fockel, David Schubert, Roman Trentinaglia, Hannes Schulz and Wolfgang Kirmair
Abstract: There is a steady trend towards increasing the connectivity of vehicles – especially for realizing automated driving functions. This also increases the attack surface, which is crucial due to the safety-criticality of vehicles. Hence, engineering methods are required, that account for both security and safety, and identify conflicts and synergies. However, in the automotive domain, newly introduced security analysis methods meet well- established safety analysis methods. Both are applied in separate silos which hinders communication and increases development effort. In this paper, we introduce an integrated safety and security analysis method that supports the analysis of correlations between attacks and hazards on an architectural level. It integrates with an existing model-based requirements engineering method, and automates modeling and analysis steps to foster regular communication with low effort in early development phases. We evaluated the approach in a case study with an automated driving function.
Download
Paper Nr: 7
Title:

Universal Safety Format: Automated Safety Software Generation
Authors:

Frederik Haxel, Alexander Viehl, Michael Benkel, Bjoern Beyreuther, Klaus Birken, Rolf Schmedes, Kim Grüttner and Daniel Mueller-Gritschneder
Abstract: The development of safety-critical software requires a significant additional effort compared to standard software. Safety mechanisms, e.g., for mitigating hardware errors, have to be designed and integrated into the functional code. This results not only in substantial implementation overhead, but also reduces the overall maintainability of the software. In this paper, we present the Universal Safety Format (USF), which enables a model-driven approach that complies with the separation of concerns principle. Software safety mechanisms are specified as patterns via a domain-agnostic transformation language, separated from the functional software. Various domain-specific tools apply these safety patterns to domain-specific artifacts, such as code or software architecture models. This enables the reuse of safety patterns in multiple designs as well as in a single design to artifacts from different domains.
Download
Paper Nr: 54
Title:

Value Creation Patterns for Industry-relevant Model-based Cyber-Physical Systems
Authors:

Nicolas C. Egger and Emanuele Laurenzi
Abstract: Recent development in technology brought Cyber-Physical Systems (CPS) to innovate across many industry fields. However, given the heterogeneous nature of the different integrated components from the virtual and physical spaces, creating a CPS requires high expertise in both engineering and the addressed application domain. Hence, a CPS is complex and time-consuming to design, deploy and test. A model-based approach can tackle this problem by enabling conceptual models to control physical objects and fostering the quick creation of Cyber-Physical Systems. The process logic and decision logic are implemented in re-usable graphical models instead of software code, which makes possible to involve domain-experts early in the design of the CPS. Given the relatively young approach, this paper explores the various model-based CPS that are relevant across industry and how they create value, respectively. For the investigation, a case study research strategy was adopted, which included both literature and a workshop targeting several industry experts. Finally, a pattern matching technique was applied to detect value proposition elements across the created cases.
Download
Paper Nr: 27
Title:

Conversion Method of MATLAB/Simulink Model for a Functional Resonance Analysis Method-based Model
Authors:

Masamichi Kakeshita, Kenji Hisazumi, Yasutaka Michiura, Keita Sakemi and Michihiro Matsumoto
Abstract: In recent years, model-based development (MBD) has become popular in control-embedded systems, and development specifications are being written using MATLAB/Simulink and other tools. The functional resonance analysis method (FRAM) is used for safety analysis of socio-technical systems. It is used to foster success factors without being trapped in failures. Application of FRAM to MBD models is expected to improve the quality of MBD models from a new perspective; however, an approach for the application of FRAM to MBD has not been established yet. Therefore, in this study, we proposed a method to convert MATLAB/Simulink models into FRAM models. Consequently, the application of the proposed method to the Simulink model led to an improvement through creation and analysis of the FRAM model. In contrast, there are certain scenarios that can occur in the Simulink model that are not represented in the completed FRAM model, as the FRAM model only represents the interactions inside the system, which makes it difficult to thoroughly analyze the system with respect to external influences. Our future work shall include a further study on how to represent information when converting MATLAB/Simulink models to FRAM models and further applying the method to Simulink models that users can directly modify.
Download
Paper Nr: 58
Title:

AI-guided Model-Driven Embedded Software Engineering
Authors:

Padma Iyenghar, Friedrich Otte and Elke Pulvermueller
Abstract: In this paper, an use case of Artificial Intelligence (AI) empowered Model Driven Engineering (MDE) in the field of Embedded Software Engineering (ESE) is introduced. In this context, we propose to qualify MDE tools for ESE with an AI assistant or a chatbot. The requirements for the first version of such an assistant and the design concepts involved are discussed. A prototype of such an assistant developed using an open source conversational AI framework used in tandem with an MDE tool for ESE is presented. Empowering MDE tools with such AI assistants, would aid novices in MDE or even non-programmer to learn and adopt model-driven ESE with a not-so-steep learning curve.
Download

Area 3 - Modeling Languages, Tools and Architectures

Full Papers
Paper Nr: 6
Title:

Integrating Security Protocols in Scenario-based Requirements Specifications
Authors:

Thorsten Koch, Sascha Trippel, Stefan Dziwok and Eric Bodden
Abstract: Software-intensive systems such as internet services, factories, or vehicles are characterized by complex functionality and strong interconnection. This interconnection leads to a high risk of cyber-attacks. To reduce this risk, software-intensive systems must fulfill various security requirements and integrate security mechanisms such as security protocols. Security protocols ensure secure communication between and within software-intensive systems. However, the application of security protocols could negatively impact other parts of the systems (e.g., its communication behavior) since the protocols introduce further messages and computing- intensive operations to the system’s behavior. Therefore, the development of software-intensive systems needs to cover functional and security aspects. This paper presents a model- and scenario-based requirements engineering approach to integrate security protocols in application-specific requirements specifications systematically. Thereby, requirements engineers with limited security knowledge can integrate established and validated security protocols in their application to increase the security. In particular, our approach provides parameterizable templates for security protocols and references these templates in other specifications. Furthermore, it provides the simulative validation of the requirements specification. We show that our approach is applicable in practice through a case study involving application scenarios from the automotive domain and established security protocols.
Download
Paper Nr: 16
Title:

Modeling Context-aware Systems: A Conceptualized Framework
Authors:

Achiya Elyasaf and Arnon Sturm
Abstract: Context-aware systems keep on emerging in all of our daily activities. Context, which can be a location, a user, an actual activity, or physical conditions, plays a major role in such systems. Actually, everything we refer to in our systems can be considered as context. To cope with this new situation, mechanisms for managing context were devised, including frameworks and programming languages. However, modeling languages that address the notion of context are rare. In this paper, we aim at framing and further defining the requirements for context modeling languages. Such a conceptualized framework sets the ground for designing and evaluating modeling languages for context-aware systems. We demonstrate a possible use of the proposed framework through the evaluation of CO-LSC, a context-oriented modeling language.
Download
Paper Nr: 21
Title:

A Model-based System Engineering Plugin for Safety Architecture Pattern Synthesis
Authors:

Yuri G. Dantas, Tiziano Munaro, Carmen Carlan, Vivek Nigam, Simon Barner, Shiqing Fan, Alexander Pretschner, Ulrich Schöpp and Sergey Tverdyshev
Abstract: Safety architecture patterns are abstract representations to address faults in the system architecture. In the current state of practice, the decision of which safety architecture pattern to deploy and where in the system architecture is carried out manually by a safety expert. This decision may be time consuming or even lead to human errors. This paper presents Safety Pattern Synthesis, a tool for automating the recommendation of safety architecture patterns during the design of safety-critical systems: 1) Safety Pattern Synthesis recommends patterns to address faults in the system architecture (possibly resulting in more than one architectural solution), 2) the user selects the system architecture with patterns based on, e.g., the criteria provided by Safety Pattern Synthesis, and 3) Safety Pattern Synthesis provides certain requirements that shall be considered in the overall safety engineering process. The proposed tool has been implemented as a plugin in the model-based system engineering tool called AutoFOCUS3. Safety Pattern Synthesis is implemented in Java while using a logic-programming engine as a backend to reason about the safety of the system architecture. This paper provides implementation details about Safety Pattern Synthesis and its applicability in an industrial case study taken from the automotive domain.
Download
Paper Nr: 41
Title:

Extraction Process of the Logical Schema of a Document-oriented NoSQL Database
Authors:

Fatma Abdelhedi, Hela Rajhi and Gilles Zurfluh
Abstract: The "schemaless" property, common to most NoSQL systems, means the absence of a data schema when creating a database (DB). This property brings an undeniable flexibility by allowing the schema to evolve during the use of DB. However, the absence of a schema is a major obstacle for developers and decision makers. Indeed, the expression of queries (of SQL type) requires a precise knowledge of this schema. In this paper, we propose an automatic process to extract the logical schema of document-oriented NoSQL DBs. We chose the OrientDB NoSQL system which appeared to be the most suitable for the application in our project, because of its ability to express rich data structures and a diversity of links between data: association, composition and inheritance links. Our solution, based on the MDA architecture, proposes to metamodel a NoSQL DB and its schema. From these metamodels, transformation rules allow to extract the schema of the DB. The implementation of this process on an OrientDB DB allows users to have all the necessary elements (class names, properties, data types and links) for the elaboration of queries. An experimentation of the process was carried out on three test-DBs as well as on two massive industrial DBs.
Download
Paper Nr: 48
Title:

Towards a MaaS Service for Cloud Service Interoperability
Authors:

Nour El Houda Bouzerzour and Yahya Slimani
Abstract: Cloud computing is an emerging computing paradigm, which provides high service availabality, high scalability as well as low usage costs. This has encouraged enterprises and individual users to embrace cloud technology. However, the lack of service interoperability (also known as the vendor lock-in) issue still persists. The vendor lock-in is caused by the cloud service providers who aim to prevent the clients from switching to other clouds or providers. The solutions to overcome the vendor lock-in addressed a specific cloud actor or a specific cloud model, which makes them not generic. Thus, we present in this paper, our Cloud Interoperability Pivot Model (CIPiMo). CIPiMo is a Model-as-a-Service, which standardizes the cloud service description languages by transforming them into a Generic Cloud Service Description model (GCSD) to make them interoperable. We rely on MDE techniques to achieve a Model-to-Model transformation. Therefore, we define mappings between the source description languages (OWL-S and WSDL) and the target language (GCSD). Furthermore, we illustrate our proposed meta-models for each language and we implement our transformations using ATL with OCL. Eventually, we use a static analyzer (AnATLyzer IDE) to validate the correctness of our transformations. We provide use cases to demonstrate the applicability of our approach.
Download
Paper Nr: 53
Title:

Code Generation by Example
Authors:

Kevin Lano and Qiaomu Xue
Abstract: Code generation is a key technique for model-driven engineering approaches of software construction. Code generation enables the synthesis of applications in executable programming languages from high-level specifications in UML or a domain-specific language. Specialised code-generation languages and tools have been defined, such as Epsilon EGL and Acceleo, however the task of writing a code generator remains a substantial undertaking, requiring a high degree of expertise in both the source and target languages, and in the code-generation language. In this paper we show how symbolic machine learning techniques can be used to reduce the time and effort for developing code generators. We apply the techniques to the development of a UML-to-Java code generator.
Download
Short Papers
Paper Nr: 8
Title:

Modeling of Intralogistic Processes for the Implementation of Warehouse Management Systems
Authors:

Markus Rabe and Felix Stadler
Abstract: Due to the growing complexity of intralogistics systems, the use of warehouse management systems (WMS) is becoming increasingly attractive for companies. As an often business-critical management system of internal material flows, however, their implementation or change is complex and carries risks. Especially the insufficient knowledge of companies about their own processes leads to a high capacity and cost burden due to the time-consuming involvement of their own experts and, often, also contracted WMS consultants. In this context, models and modeling methods are gaining additional importance. But, particularly in intralogistics, with its special demands and characteristics, there is a lack of methodological support for mapping and transferring process knowledge appropriate for the WMS implementation. The consequences, besides a low level of acceptance among the affected employees, are project aborts and production downtimes. This paper discusses experiences from industrial practice during the implementation of WMS and takes the position that a supporting method is urgently required in this context. Therefore, we propose the development of a modeling language for mapping intralogistic processes in line with the requirements for the implementation of WMS as well as procedural method components that support the generation and transmission of the process knowledge.
Download
Paper Nr: 10
Title:

SysML Models Verification Relying on Dependency Graphs
Authors:

Ludovic Apvrille, Pierre De Saqui-Sannes, Oana Hotescu and Alessandro T. Calvino
Abstract: Formal verification of SysML models contributes to early detection of design errors early in the life cycle of systems. Incremental modeling of systems leads to the repeated verification of parts of systems models that were already verified in previous versions of the SysML model. This paper proposes to optimize the verification process by generating dependency graphs from SysML models. This revisited verification technique is now supported by TTool. It is illustrated with an Avionics Full DupleX network.
Download
Paper Nr: 12
Title:

Verifiable Executable Models for Decomposable Real-time Systems
Authors:

Callum McColl, Vladimir Estivill-Castro, Morgan McColl and René Hexel
Abstract: Formally verifiable, executable models allow the high-level design, implementation, execution, and validation of reliable systems. But, unbounded complexity, semantic gaps, and combinatorial state explosion have drastically reduced the use of model-driven software engineering for even moderately complex real-time systems. We introduce a new solution that enables high level, executable models of decomposable real-time systems. Our novel approach allows verification in both the time domain and the value domain. We show that through 1) the use of a static, worst-case execution time, and 2) our time-triggered deterministic scheduling of arrangements of logic-labelled finite-state machines (LLFSMs), we can create succinct Kripke structures that are fit for formal verification, including verification of timing properties. We leap further and enable parallel, non-preemptive scheduling of LLFSMs where verification is feasible as the faithful Kripke structure has bounded size. We evaluate our approach through a case study where we fully apply a model-driven approach to a hard time-critical system of parallel sonar sensors.
Download
Paper Nr: 14
Title:

Ontology-based Detection of Inconsistencies in UML/OCL Models
Authors:

Shan Lu, Alexey Tazin, Yanji Chen, Mieczyslaw M. Kokar and Jeff Smith
Abstract: Consistency checking of UML/OCL models is a challenging issue in software development. In this paper, we discuss an OWL/ontology-based method to detect the inconsistencies in the UML/OCL models as the first step of requirement change management. Specifically, we map the UML/OCL models to OWL, so that the consistency of the corresponding ontology can be checked by OWL reasoners automatically. We propose a set of mapping rules to interpret the components of UML state machine diagrams, along with OCL constraints, to OWL DL. Towards this objective, we demonstrate three consistency reasoning tasks over a state machine diagram using OWL reasoners. In each case, the result of reasoning is accompanied by an explanation of the logic behind the decision.
Download
Paper Nr: 15
Title:

Formal Scenario-driven Logical Spaces for Randomized Synthetic Data Generation
Authors:

Osama Maqbool and Jürgen Roßmann
Abstract: Simulations and synthetic data are a necessary supplement to real-world experiments in order to alleviate its effort, cost and risks. As demand of data for development and validation increases, simulations too must correspondingly be scaled. Variation of simulation parameters affords simulation designers control over the scope of how a simulation is scaled— they can chose a balance between target distribution of simulation variants and the degree of randomness— thereby achieving both the volume and diversity of synthetic data. This paper proposes logical scenarios as basis for simulation variation. Scenarios are formal human-readable scripts of simulations and test drives used within the automotive industry. They are defined at different abstraction levels, one of which is the logical scenario as a parameterized simulation model with description for parameters instead of concrete values. This contribution proposes methodologies to model the parameter descriptions in a modular fashion with parameter ranges, probability distributions and inter-relations. A randomization engine is introduced based on Markov chain Monte-Carlo methods to efficiently sample the modeled space. The result is a variety of simulation-independent concrete scenarios that follow the formal scenario specification.
Download
Paper Nr: 18
Title:

Use of Compiler Intermediate Representation for Reverse Engineering: A Case Study for GCC Compiler and UML Activity Diagram
Authors:

Rania Mzid, Asma Charfi and Najmeddine Etteyeb
Abstract: Nowadays systems are no longer made from scratch, they use existing third-party components or legacy software. Providing methods/techniques to facilitate the comprehension of existing software is beneficial to increase productivity, especially when dealing with their reuse and/or modernization. Model Driven Engineering (MDE) offers a set of guidelines to manage the complexity of software systems during their development. In that context, the reverse-engineering process aims to describe a source code at higher level of abstraction using automatic transformations. This paper proposes an extensible MDE approach for behavioural reverse engineering. The proposed approach aims to make the reverse transformation independent of the source programming language. Starting from a given source code written in any programming language, the proposed approach integrates an intermediate step based on compiler’s front-end to generate an intermediate representation. Then, it performs a model transformation to extract behavioural aspects from the source code and generates a graph that describes its control flow. The different steps of the approach are automated. We apply the approach to case study using GCC and GIMPLE as intermediate representation and UML activity diagram as control flow graph to show its viability.
Download
Paper Nr: 25
Title:

From Monolithic Models to Agile Micromodels
Authors:

Sebastian Copei, Christoph Eickhoff, Adam Malik, Natascha Nolte, Ulrich Norbisrath, Jonas Sorgalla, Jens H. Weber and Albert Zündorf
Abstract: This paper proposes a new modeling approach that allows to split classical monolithic class models into a system of small micromodels. The events of such a system are modeled through an additional Event Storming. This new approach facilitates evolution as Event Storming uses events with relatively simple structures and new events may be added easily. Similarly, sets of micromodels are more evolveable as changes remain local to only those micromodels that are concerned by the particular subset of changed events. Different micromodels communicate via a small set of dedicated “interface" events, which again aids evolution.
Download
Paper Nr: 28
Title:

Experimental Comparison of Two Goal-oriented Analysis Techniques
Authors:

Carlos Cano-Genoves, Silvia Abrahão and Emilio Insfran
Abstract: Background: Goal-oriented analysis techniques help reason and make decisions about goal models. These models may represent the stakeholders’ intentions with respect to the software system to be developed. In a previous work, we proposed VeGAn, a goal-oriented analysis technique that follows a value-driven approach in order to support decision-making. Aims: This paper compares the VeGAn technique with the GRL-Quant technique, with respect to the accuracy of goal model element prioritization, the participants’ prioritization time, and their perceptions of the quality of the analysis results (perceived satisfaction). Method: A controlled experiment was carried out with 64 Computer Science undergraduate students who analyzed a goal model using each of the techniques compared. Results: The results of the experiment show that there are no significant differences between prioritization time. However, the perceived satisfaction was superior for VeGAn, although the prioritization accuracy of GRL-Quant was better for one particular system. Conclusions: While further research is required in order to strengthen these results, the experiment provides preliminary results on the usefulness of both goal-oriented analysis techniques. Several insights have emerged from this study, and also opportunities to improve both techniques.
Download
Paper Nr: 36
Title:

Approach to Reference Models for Building Performance Simulation
Authors:

Sahil-Jai Arora, Clara Ceccolini and Markus Rabe
Abstract: In the fields of business process modeling, logistics, and information model development, Reference Models (RMs) have shown to enhance standardization, support the common understanding of terminology and procedures, reduce the modeling efforts and cost through the paradigm ”Design by Reuse”, and enable knowledge transfer. The use of RMs in Building Performance Simulation (BPS) shows potential to achieve similar benefits. Firstly, to clarify the terminology adopted in the different fields, this paper presents a comprehensive overview of the diversely interpreted definitions, benefits, and attributes of RMs and related terms, including classification into common and uncommon understanding. Secondly, the paper transfers the approach of RMs to BPS. A definition for RMs applicable to BPS is provided, the identified RM qualities are matched with BPS’s challenges, and finally an example of an RM for simulation-based test benches is presented.
Download
Paper Nr: 38
Title:

Towards a Goal-oriented Method for Software Solutions Prioritization
Authors:

Prisca Petelo, Abderrahmane Leshob, Benzarti Imen and Hafedh Mili
Abstract: Architecture practitioners, such as enterprise architects, solutions architects, and application architects are often faced with the problem of selecting the best software solutions that implement the requirements and satisfy the business objectives. Examples of these solutions are: web services, software components, and full software applications. To identify the best solution, architects often have to prioritize the candidate solutions according to a set of criteria, such as their quality attributes, their contributions to satisfy the (business) objectives, and their cost of implementation. This work aims to design a method that helps architects to identify the optimal solution that achieves the requirements and efficiently satisfies the business objectives. The proposed method is composed of three steps. First, it builds a goal model that links each candidate solution to: i) the functional requirements to be implemented and ii) the desired objectives to be satisfied. The goal model uses the Archimate language. It connects the requirements, goals and solutions together according to the Goal-oriented Requirement Language (GRL) rules. Second, the method computes automatically satisfaction scores that measure the effectiveness of each solution. Third, the method prioritizes the solutions according to their satisfaction scores. This work presents the principles underlying the proposed method and discusses its possible application in the practice.
Download
Paper Nr: 42
Title:

Historical Knowledge Modelling and Analysis through Ontologies and Timeline Extraction Operators: Application to Computing Heritage
Authors:

Christophe Ponsard, Aurélien Masson and Ward Desmet
Abstract: Cultural heritage as human science has a long tradition of text-based reporting and analysis. This domain has a very rich semantic structure, especially to relate many different types of entities anchored in some time period with more or less strong temporal inter-dependencies. Various modelling approaches, largely based on ontologies, have been proposed to capture and structure this kind of knowledge. In this paper, we are interested in easing the analysis capabilities on historical knowledge using the timeline as central concept that can be extracted and manipulated in various ways through specific operators sharing some similarities with multi-dimensional analysis in business intelligence. We propose zooming on a specific aggregates, pivoting from a timeline to another one or drilling-across to compare different timelines. Our work is illustrated on a concrete implementation targeting the Computing Heritage of the micro-computer period, including machines, operating systems, companies, people and applications. The information is extracted from a museum information system combined with DBPedia. We also developed a specific visualisation tool under the form of a mobile application which can also be used as museum guide.
Download
Paper Nr: 44
Title:

Scenario-assisted Deep Reinforcement Learning
Authors:

Raz Yerushalmi, Guy Amir, Achiya Elyasaf, David Harel, Guy Katz and Assaf Marron
Abstract: Deep reinforcement learning has proven remarkably useful in training agents from unstructured data. However, the opacity of the produced agents makes it difficult to ensure that they adhere to various requirements posed by human engineers. In this work-in-progress report, we propose a technique for enhancing the reinforcement learning training process (specifically, its reward calculation), in a way that allows human engineers to directly contribute their expert knowledge, making the agent under training more likely to comply with various relevant constraints. Moreover, our proposed approach allows formulating these constraints using advanced model engineering techniques, such as scenario-based modeling. This mix of black-box learning-based tools with classical modeling approaches could produce systems that are effective and efficient, but are also more transparent and maintainable. We evaluated our technique using a case-study from the domain of internet congestion control, obtaining promising results.
Download
Paper Nr: 49
Title:

Classification Scheme for the Concrete Syntax of Graph-like Modeling Languages for Layout Algorithm Reuse
Authors:

Gregor Wrobel and Robert Scheffler
Abstract: Graph-like modeling languages (GLML) are deployed in various domains. In model-based software engineering they are used directly or indirectly for the development of software. In different engineering systems, graph-like models are artifacts (circuit diagrams, energy flow diagrams) of the respective domain, which serve as input for downstream specialized applications (simulators, optimizers). When developing modeling tools, the concrete syntax of a language for creating, editing, and understanding models is immensely important. In order to develop tools with good usability, layout algorithms for the used languages have to be integrated. The development of these layout algorithms is particularly complex. With graph drawing there is a specialized field that deals with the development of layout algorithms for graphs. Some of these algorithms can be used for the layout of GLML or be adapted for GLML. In order to allow the reuse of layout algorithms and their assignment to a certain class of GLML, a classification scheme for the concrete syntax for GLML is presented in this paper.
Download
Paper Nr: 50
Title:

Towards Model Transformation with Structural Level-spanning Patterns
Authors:

Sándor Bácsi and Gergely Mezei
Abstract: In MDE, models are meant to be transformed, thus model transformation is one of the basic pillars of MDE. Besides generating source code, transformation is often used to refactor or optimize the models. While the theory and application of graph transformations are active research fields for many years now, existing approaches focus mainly on classic two-level meta-modeling setups. It is a promising research direction however to use graph pattern-based transformations on multi-level models as well. This position paper proposes a textual model transformation language — the DMLA Transformation Language (DTL) — which enables the definition of level-spanning transformation rules in a level-blind multi-layer environment.
Download
Paper Nr: 20
Title:

A Method for Detecting Common Weaknesses in Self-Sovereign Identity Systems Using Domain-Specific Models and Knowledge Graph
Authors:

Charnon Pattiyanon, Toshiaki Aoki and Daisuke Ishii
Abstract: A Self-Sovereign Identity (SSI) system is a decentralized identity management system based on claims that leverages blockchain technology to empower individuals to manage their personal information and autonomously authenticate services. The SSI system is unique in that it makes use of disparate terminologies, making analysis arduous and challenging for security specialists. Weakness analysis is a well-known security assurance technique for determining the presence of weaknesses in a target system. Weakness analysis is crucial to the deployment of the SSI system in that it can earn user trust and be verified secure if the majority of detected weaknesses are addressed properly. We seek to leverage domain experience in this work to lessen the effort required to analyze weaknesses by security specialists unfamiliar with the SSI system. This paper presents two domain-specific modeling languages (DSMLs) based on the unified modeling language (UML) communication diagram for embedding domain knowledge about the SSI system and common weaknesses. Then, with the assistance of domain knowledge graphs, this paper presents a method for detecting weaknesses in the links between the two models created by the proposed DSMLs. Precision and accuracy metrics are used to determine the proposed method’s performance.
Download
Paper Nr: 46
Title:

SHORE: A Model-driven Approach That Combines Goal, Semantic and Variability Models for Smart HOme self-REconfiguration
Authors:

Denisse Muñante, Bruno Traverson, Sophie Chabridon and Amel Bouzeghoub
Abstract: Smart Homes, and more generally the Internet of Things (IoT), are gaining more and more audience, but this kind of environment is still challenging on several aspects. Semantic representations, mainly ontologies, have been used to cope with the complexity and lack of interoperability due to the wide variety of objects and services. However, these semantic representations do not permit a fine description of variability and evolution to achieve particular objectives. Therefore, in this paper, we introduce a model-driven approach, so-called SHORE for Smart HOme self-REconfiguration, which addresses these limitations and covers the complexity and variability of Smart Homes allowing automated reconfiguration guided by their goals. Thus, SHORE includes artifacts, based on goal, semantic and feature models, that are used at design-time to conceptualise Smart Homes, their variants and goals. Whilst, at runtime, SHORE exploits these artifacts to detect situations that require reconfiguration, i.e., detect deviations from their goals, and then to calculate optimal reconfiguration plans to cope with these situations.
Download
Paper Nr: 51
Title:

The Challenges of Defining and Parsing Multi-Layer DMLA Models
Authors:

Norbert Somogyi and Gergely Mezei
Abstract: Parsing is a principal step of processing languages. The nature of the language tends to determine the challenges that parsers must overcome. For example, parsing procedural or object-oriented languages often require approaches that may be specific to the targeted paradigm. For this reason, the properties of the given language may also affect the capabilities of the parser. The Dynamic Multi-Layer Algebra (DMLA) is a multi-layer metamodeling approach that aims to improve upon the flexibility of traditional meta-modeling methods. In addition, DMLA ensures rigorous validation of domain rules. In DMLA, domain models and validation logic are described in D#, a domain specific language designed specifically for this purpose. Scripts written in D# are parsed and an inner, 4-tuple representation is built. However, due to the multi-layer background and the completely modeled language, parsing DMLA models raises non-conventional difficulties that must be overcome. Reaching a satisfying balance between the expressive power and the concisity of the language is also desirable. In this paper, we present the parsing process of DMLA, its peculiarities and the solutions we have employed to deal with them.
Download
Paper Nr: 56
Title:

Platform-independent Specifications for Robotic Process Automation Applications
Authors:

Carlos M. Correia and Alberto Rodrigues da Silva
Abstract: Robotic Process Automation (RPA) is an emerged technology that uses software robots to automate human- intensive repetitive tasks, traditionally associated with bureaucratic and low-complexity processes. This article introduced a concrete scenario implemented with three popular RPA tools (i.e., UiPath, Robocorp, and Robot Framework), which supported the research. First, the paper introduces informally that scenario, implemented with the platform-specific languages of these tools, namely with keyword-based scripts and other visual models. The challenge addressed in this paper is how to describe RPA applications (or just soft robots) in a platform-independent way, close to natural language, and easily understandable by technical and non-technical people. Established on the preliminary results, we conclude that adopting controlled natural languages based on use cases and scenarios simplifies the specification and development of RPA scenarios, no matter the supported RPA tool. For future works, we intend to use the best notation to specify robots in a platform-independent way and implement transformation mechanisms for the proprietary format of popular RPA tools such as UiPath, Robot Framework, and Robocorp.
Download