Gianna Reggio

Consistency problems in UML-based software development

This survey of the workshop series Consistency Problems in UML-based Software Development aims to help readers to find the guidelines of the papers. First, general considerations about consistency and related problems are discussed. Next, the approaches proposed in the workshop papers to handle the problems are categorized and summarized. The last section includes extended abstracts of the papers from the current workshop.

Analysing UML Active Classes and Associated State Machines - A Lightweight Formal Approach

We propose a precise definition of UML active classes through associated labelled transition systems using the algebraic specification language Casl. We are convinced that the first step to make UML precise is to find an underlying formal model for the systems modelled by UML, and we argue that labelled transition systems are a sensible choice. This modelization will help understanding the UML constructs and will improve their use in practice. One of our aims is, in the future, to use the powerful animation and verification tools available for algebraic specifications with UML specifications. We simplify the problem of the applicability of our semantics by restricting the state machine constructs considered. This restriction does not, however, narrow the UML subset in study because the restricted constructs can be replaced by equivalent combinations of other constructs. Because of some ambiguities in the UML official semantics, we discuss the several options at hand and choose, for each ambiguous case, the semantics that either makes more sense or that allows to simplify the problem the most.

Towards a Rigorous Semantics of UML Supporting Its Multiview Approach

We discuss the nature of the semantics of the UML. Contrary to the case of most languages, this task is far from trivial. Indeed, not only the UML notation is complex and its informal description is incomplete and ambiguous, but we also have the UML multiview aspect to take into account. We propose a general schema of the semantics of the UML, where the different kinds of diagrams within a UML model are given individual semantics and then such semantics are composed to get the semantics on the overall model. Moreover, we fill part of such a schema, by using the algebraic language CASL as a metalanguage to describe the semantics of class diagrams, state machines and the complete UML formal systems.

SMoLCS-driven concurrent calculi

It is shown how to derive, following the principles of the SMoLCS methodology, a family of calculi, suitable for the specification of concurrent systems and languages. A calculus consists basically of a language for expressing behaviours and their parallel composition together with the rewriting rules defining their semantics; formally it is a calculus associated to an algebraic parameterized specification: for every choice of the parameters we fix one calculus in the family. The distinguishing feature of our calculi is that the combinators for behaviours include functional abstraction and application, so that behaviours can be passed as arguments and obtained as results of functions; in general behaviours can be seen just as a data type and in this sense our calculi can be higher order calculi with behaviours as first class objects.

Relevance, benefits, and problems of software modelling and model driven techniques-A survey in the Italian industry

Context: Claimed benefits of software modelling and model driven techniques are improvements in productivity, portability, maintainability and interoperability. However, little effort has been devoted at collecting evidence to evaluate their actual relevance, benefits and usage complications. Goal: The main goals of this paper are: (1) assess the diffusion and relevance of software modelling and MD techniques in the Italian industry, (2) understand the expected and achieved benefits, and (3) identify which problems limit/prevent their diffusion. Method: We conducted an exploratory personal opinion survey with a sample of 155 Italian software professionals by means of a Web-based questionnaire on-line from February to April 2011. Results: Software modelling and MD techniques are very relevant in the Italian industry. The adoption of simple modelling brings common benefits (better design support, documentation improvement, better maintenance, and higher software quality), while MD techniques make it easier to achieve: improved standardization, higher productivity, and platform independence. We identified problems, some hindering adoption (too much effort required and limited usefulness) others preventing it (lack of competencies and supporting tools). Conclusions: The relevance represents an important objective motivation for researchers in this area. The relationship between techniques and attainable benefits represents an instrument for practitioners planning the adoption of such techniques. In addition the findings may provide hints for companies and universities.

On the parameterized algebraic specification of concurrent systems

A technique for specifying concurrent systems is shown, that uses the algebraic specification language ASL. A system is algebraically specified as a transition system and a concurrent system is the result of composing systems by three basic operations: synchronization, parallel composition and monitoring. These operations are schematically described using the parameterization concept of ASL and they are in the same time examples for the power of ASL since they cannot be formally specified in other specification languages. Each particular synchronization, parallel composition or monitoring is defined by instantiating on appropriate parameters a unique specification, which produces a transition system out of an input transition system. By combining the three operations we obtain a formal support for a methodology of hierarchical and modular specification of concurrent systems. Moreover it is shown that combining tools for defining semantics in ASL with the above parameterized schema provides a standard way for giving to a concurrent system a variety of semantics depending on observability constraints.

Scientific Engineering of Distributed Java Applications

The purpose of this paper is to investigate how several innovative techniques, not all initially intended for fault-tolerance, can be applied in providing fault tolerance of complex mobile agent systems. Due to their roaming nature, mobile agents usually run on Java-based platforms, which ensures full portability of mobile code. The first part of the paper discusses specific characteristics of mobile systems, outlines the application areas benefiting from cede mobility, and shows why the existing error recovery techniques are not suitable for mobile systems. In the next part of the paper we present evaluation criteria for fault tolerance techniques, and propose several possible solutions for error recovery at the application level: meta-agent, Coordinated Atomic actions, asynchronous resolution, self-repair, and proof carrying code. The intention is to allow system developers to choose the approach which is suited best to the characteristics of the mobile agent application to be designed. To this end we discuss the advantages and disadvantages of each technique, as well as situations in which it provides the most benefit. A simple example, based on Internet shopping, is used throughout the paper to demonstrate the techniques.The use of open technologies and standards have made easier the integration of Web services into end-applications. These interoperable services have been organized on distributed architectures over Internet in accordance with shared functional principles. But these Web-service architectures have not resolved the distributed computing difficulty in ”gluing together” multiple and independent Web services. This paper presents an approach based on Java technology and Internet standard protocols and data formats for resolving coordination problems among Web services. Interaction models based on distributed events over HTTP are supported for providing the required coordination functionality. Cooperation problems and their solutions have been studied in the prototypical context of Location-Based Services.

CASL-CHART: A Combination of Statecharts and of the Algebraic Specification Language CASL

In this paper we present Casl-Chart a formal visual specification language for reactive systems obtained by combining an already existing language for reactive systems, precisely the statecharts as supported by Statemate ([6,7]), with an already existing language for the specification of data structures, precisely the algebraic specification language Casl ([12,17]).

Maturity of software modelling and model driven engineering: A survey in the Italian industry

Background: The main claimed advantage of model driven engineering is the improvement of productivity. However, little information is available about its actual usage during software development and maintenance in the industry. Objective: The main aim of this work is investigating the level of maturity in the usage of software models and model driven engineering in the Italian industry. The perspective is that of software engineering researchers. Method: First, we conducted an exploratory personal opinion survey with 155 Italian software professionals. The data were collected with the help of a web-based on-line questionnaire. Then, we conducted focused interviews with three software professionals to interpret doubtful results. Results: Software modelling is a very relevant phenomenon in the Italian industry. Model driven techniques are used in the industry, even if (i) only for a limited extent, (ii) despite a quite generalized dissatisfaction about available tools and (iii) despite a generally low experience of the IT personnel in such techniques. Limitations: Generalization of results is limited due to the sample size. Moreover, possible self-exclusion from participants not interested in modelling could have biased the results. Conclusion: Results reinforce existing evidence regarding the usage of software modelling and (partially of) model driven engineering in the industry but highlight several aspects of immaturity of the Italian industry.

Preliminary Findings from a Survey on the MD State of the Practice

In the context of an Italian research project, this paper reports on an on-line survey, performed with 155 software professionals, with the aim of investigating about their opinions and experiences in modeling during software development and Model-driven engineering usage. The survey focused also on used modeling languages, processes and tools. A preliminary analysis of the results confirmed that Model-driven engineering, and more in general software modeling, are very relevant phenomena. Approximately 68% of the sample use models during software development. Among then, 44% generate code starting from models and 16% execute them directly. The preferred language for modeling is UML but DSLs are used as well.