MiSE '18- Proceedings of the 10th International Workshop on Modelling in Software Engineering

Many modern systems are built to be in use for a long time, sometimes spanning several decades. Furthermore, considering the cost of replacing an existing system, existing systems are usually adapted to evolving requirements, some of which may be anticipated. Such systems need to be specified and analyzed in terms of whether the changes introduced into the system still address evolving requirements and continue to satisfy the needs of its stakeholders. Recently, the User Requirements Notation (URN) - a requirements engineering notation standardized by the International Telecommunication Union for the elicitation, specification, and analysis of integrated goal and scenario models - has been extended with support for the modeling and analysis of evolving requirements models by capturing a comprehensive set of changes to a URN model as first-class model concepts in URN. The extension is called TimedURN and this paper builds on TimedURN to analyze and visualize not just an individual time point in the past, present, or future but a time range consisting of a set of time points. Various visualization options are discussed, including their proof-of-concept implementation in the jUCMNav requirements engineering tool.

The paper presents a preliminary version of lotReq, a method for the elicitation and specification of the requirements for an IoT-system. The first task suggested by lotReq is the modelling of the domain, using the UML and following the service-oriented paradigm, then the goals of the IoT-system to build are elicited and specified, again using the UML and extending the domain model, producing a specification of the functional requirements. lotReq also provides preliminary indications for specifying the technological nonfunctional requirements.

A case study, the specification of the requirements for a system to support the Genoa's Science Festival is presented too.

Sequence and class diagrams are widely used to model the behavioral and structural aspects of a software system. A size metric that is defined automatically countable from sequence and class diagrams boosts both the efficiency and the accuracy of size estimation by producing reproducible software size measurements. To fulfill the purposes, a size metric called Detailed Use Case Points (DUCPs) is proposed based on the information automatically derived from sequence and class diagrams. The automation is largely supported by our proposed user-system interaction model (USIM) that fills the gap between the system abstraction by the sizing model and the metamodels of the UML diagrams. The effectiveness of our proposed size metric in project effort estimation is validated by an empirical study of 22 historical projects.

Model extraction allows the automatic construction of behaviour models from an available implementation, which can be fed into existing analysis tools. Even though these models are usually analysed using qualitative properties, many interesting and relevant properties of current systems are related to quantitative aspects, such as the probability of reaching a certain state or how many times a certain task is expected to be executed. In this work, we extend an existing model extraction approach to include probabilistic information. The original approach creates Labelled Transition Systems (LTS) from Java code based on execution traces. The traces are processed by a tool that identifies contexts, which represent abstract states of the system, considering static and dynamic information, producing context traces. We use these context traces to calculate transition probabilities and generate models in the input language of a probabilistic model checker. We evaluate our approach in case studies and demonstrate that, by using context traces rather than simple traces, we produce more accurate models, thereby with probabilistic information closer to the real behaviour of programs, based on their observed traces. We also show how to build models of programs with single and multiple components.

Context: UML software development relies on different types of UML diagrams, which must be consistent with one another. UML Synthesis techniques suggest to generate diagram(s) from other diagram(s), thereby implicitly suggesting that input and output diagrams of the synthesis process be consistent with one another.

Objective: Our aim is to provide a comprehensive summary of UML synthesis techniques as they have been described in the literature to date to then collect UML consistency rules, which can then be used to verify UML models. Method: We performed a Systematic Mapping Study by following well-known guidelines. We selected 14 studies by means of a search with seven search engines executed until January, 2018. Results: Researchers have not frequently published papers concerning UML synthesis techniques since 2004. We present a set of 47 UML consistency rules collected from the different synthesis techniques analyzed. Conclusion: Although UML diagrams synthesis doesn't seem to be an active line of research, it is relevant since synthesis techniques rely on enforcing diagram consistency, which is an active line of research. We collected consistency rules which can be used to check UML models, specifically to verify if the diagrams of a model are consistent with one another.

The development of software-intensive systems, such as automotive systems, is becoming more and more complex. To cope with this complexity, the developers use several modelling formalisms and languages to describe the same system from different viewpoints at multiple levels of abstraction. The used heterogeneous models can share common semantics and are usually separately developed and reused in different projects. This poses a challenge to the developer to keep them consistent along the development process.

The Vitruvius approach for view-based software development provides change-driven consistency preservation between heterogeneous models. Vitruvius uses predefined consistency rules to support the consistent development of heterogeneous models. The developers of existing software models can benefit from Vitruvius advantages only if they integrate their models into its consistency preservation mechanism.

This paper extends Vitruvius with semi-automated legacy models integration, i.e. the ability to import multiple existing models into the consistency preservation mechanism. For this purpose, we propose an algorithm for automatic consistency checking of multiple existing models and for semi-automatic resolving of the potential conflicts. This algorithm is evaluated by a case study from automotive systems development. In this case study, we integrate existing models in the languages SysML, AMALTHEA and ASCET.

Domain-specific modelling with domain-specific languages (DSL) is rapidly gaining popularity in both research and industry for representing models of a target domain. However for a broader adoption, MDE tools need to provide adequate support for building these DSLs as well as for using the DSLs.

We have been using the Papyrus modelling tool for domain-specific modelling. Papyrus implements the OMG UML 2 standard and uses the UML Profiling mechanism to model domain-specific notions. It has significantly evolved over the past years and is now considered to be industry ready. In this paper, we share our experiences on using the tool for domain-specific modelling. We base our work on the advanced customizability features for domain-specific modelling offered by Papyrus. However, we soon came to realize that creating a domain-specific modelling environment is a non-trivial task with Papyrus. We elaborate on the issues we encountered and on the steps taken to overcome them. As a possible solution for language engineers, we also developed a tool which can be used to automatically generate domain-specific modelling environments based on a given profile in Papyrus.

Distributed streaming applications, i.e. applications that process massive and potentially infinite streams of data, are becoming increasingly popular in order to tame at the same time the velocity and the volume of Big Data. Designing and developing distributed streaming applications is currently difficult because it involves the employment of 1) complex programming paradigms to deal with the unboundedness of data streams together with 2) distributed streaming engines, each coming with its own APIs. To address the above shortcomings, in this tool demo paper we present StreamGen, a model-driven tool aiming at simplifying the development of distributed streaming applications. StreamGen provides (i) a UML profile to add streaming-specific concepts to standard UML Class Diagrams and (ii) a model-to-text transformation to automatically generate the application code starting from UML models.

Background: Large and complex diagrams are hard to understand, yet sometimes unavoidable. In other disciplines, diagrams are routinely organized into layers to tackle complexity-why not in Software Engineering?

Objective: We want to understand whether layered diagrams are a useful addition to the software engineers repertoire. If so, how are layers best used, and what features and properties should they have?

Method: First, we explore the design space. We study how layers are used in other disciplines, discuss sample layered diagrams, and derive design decisions. We implement layered diagrams in an experimental modeling tool, and provide an initial validation, exploring the usage space in a field study.

Results: Layers are intuitive to use and benefit many usage scenarios that are poorly supported by most contemporary tools.

Conclusions: Layered diagrams complement conventional diagrams and model structuring techniques. They are easy to comprehend and apply by modelers, and allow richer models. With layered diagrams, the utility and usability of existing modeling tools can be improved at little cost.

The use of Multiagent Systems (MAS) has been increasing over the years due to their capacity of dealing with problems in a variety of domains. The modeling of such systems is not trivial: besides the knowledge and skills on agent-oriented software engineering and a basic understanding of the target domain to be modeled, it demands familiarity with agent-oriented modeling methodologies. This is not always the case, though, especially for newcomers in the field. This work proposes a set of guidelines in the form of a questionnaire for the evaluation of MAS models, aiming at supporting the verification of their quality. The questionnaire is built upon the results of a systematic mapping conducted to identify how MAS models have been evaluated and what metrics have been used. The proposed guidelines were evaluated through (i) a peer review by experts and (ii) its actual application by graduate students applying modeling methodologies in the context of Guardian Angel (GA), a patient-centered health system that automatically supports patients suffering from chronic diseases. Participants provided an overall positive feedback and proposed some improvements on the questionnaire, most of which were promptly incorporated.