Abstract In this paper, we present Precise SOM (Precise Service Oriented Modelling) —a novel lightweight method for integrated domain and business process modelling—which follows the service‐oriented paradigm, uses a UML profile as notation and provides detailed workflows to guide the production of the models. In our method, the UML models are precisely defined by means of a metamodel and of a set of constraints, and by restricting UML to the essential language constructs, to help modellers to avoid common mistakes and to guarantee, by construction, a good quality. Precise SOM has been validated by detailing how it can be used in various modelling tasks, some of them illustrated by a (industrial) case study.

Nowadays, no one doubt that big data and analytics are fundamental tools for successfully running an enterprise. However, big data/analytics projects do not seem to be all sunshine and rainbows, and this is documented by many sources providing startling figures of failed projects. Motivated by such figures, we conducted a (grey and scientific) literature review aimed to answer: RQ1) Which are the documented cases of failed BD/A projects, and which are the root causes of their failures?RQ2) What is assumed useful to reduce the chance of failure of BD/A projects? We collected and examined 188 sources. The survey resulted first in a list of hints for helping avoid the failure of the BD/A projects (RQ2), and in a list of 21 cases of failed BD/A projects documented in the literature (RQ1). The analysis of those failures resulted in confirming the hints of RQ2 and prompting other relevant ones. The result of this study will be useful not only to people developing a BDA project but also to researchers investigating the challenges proposed by a BDA project to the traditional methods of software engineering.

When modellers have to describe a business process, they can decide to rely on one of the several notations currently available such as for instance BPMN or UML. However, it is not easy to select the most appropriate one. Indeed, even though in the literature several comparisons among notations have been proposed, often they focus on specific properties of the notations or on their constructs. On the contrary, the real concern of the modeller is to select the best modelling method, based on a notation they know for a specific modelling case. For this reasons, in this work we further raise the level of comparison by proposing an approach based on matching the features, required by the modelling case that the modeller has to face, with the ones supported by available modelling methods based on those notations. In this way the modeller can really select the best method (based on a modelling notation) according to the needs of the specific modelling case.

Currently, several notations can be used for modelling business processes, and various researchers tried to compare them focusing on their specific properties or constructs. We propose an approach that, instead of resulting in selecting a notation, drives to pair specific business process modelling cases with suitable modelling methods, by matching the features required by the former with the ones supported by the latter.

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.

UML is a large notation offering many diagrams and a large set of constructs for each of them covering any possible modelling need. As a result its specification is a huge book, its metamodel is large, and defining/understanding its static and dynamic semantics is difficult. These features have a negative impact on the perception of the UML and lead in some cases to replace it by ad-hoc lean and simple DSLs. On the other hand, people naturally tend to downsize UML considering only a part of its constructs. Thus, the following question arises: which are the most/less used UML diagrams/constructs? We would like to answer to this question by means of a survey, trying to detect which parts of the UML are the most used. In this work, we focus our attention on the usage of the Activity Diagram constructs. To see how much a construct is used we preliminarily investigate books, ourses/tutorials, and tools covering UML. As future work, we will conduct a personal opinion survey on the same topic.

Over the last few years, the software engineering community has proposed a number of modeling methods to represent functional requirements. Among them, use cases are recognized as an easy to use and intuitive way to capture and define such requirements. Screen mockups (also called user-interface sketches or user interface-mockups) have been proposed as a complement to use cases for improving the comprehension of functional requirements. In this article, we aim at quantifying the benefits achievable by augmenting use cases with screen mockups in the comprehension of functional requirements with respect to effectiveness, effort, and efficiency. For this purpose, we conducted a family of four controlled experiments, involving 139 participants having different profiles. The experiments involved comprehension tasks performed on the requirements documents of two desktop applications. Independently from the participants' profile, we found a statistically significant large effect of the presence of screen mockups on both comprehension effectiveness and comprehension task efficiency. No significant effect was observed on the effort to complete tasks. The main pragmatic lesson is that the screen mockups addition to use cases is able to almost double the efficiency of comprehension tasks.

In this poster, we sketch our research plan about a “massive” empirical evaluation of model-driven techniques following the first two already conducted steps in that respect (an exploratory survey and a series of controlled experiments concerning maintainability). We intend to experiment UML-based model-driven techniques in several contexts (e.g., desktop and Web applications), focusing on several software characteristics (e.g., maintainability and productivity) and employing empirical methods such as controlled experiments, surveys, case studies.

Background: The main claimed advantage of Model-driven engineering is improvement in productivity. However, few information is available about its actual adoption during software development and maintenance in the industry. Objective: The main aim of this work is investigating the level of maturity in the adoption of software models and of 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

We conducted a personal opinion survey in two rounds - years 2008 and 2011 - with the aim of investigating the level of knowledge and adoption of SOA in the Italian industry. We are also interested in understanding what is the trend of SOA (positive or negative?) and what are the methods, technologies and tools really used in the industry. The main findings of this survey are the following: (1) SOA is a relevant phenomenon in Italy, (2) Web services and RESTFul services are well-known/used and (3) orchestration languages and UDDI are little known and used. These results suggest that in Italy SOA is interpreted in a more simplistic way with respect to the current/real definition (i.e., without the concepts of orchestration/choreography and registry). Currently, the adoption of SOA is medium/low with a stable/positive trend of pervasiveness.

One of the claimed advantages of Model-driven development is the improvement in maintainability. However, few studies consider this aspect from an empirical point of view. This paper reports the results of a controlled experiment with 21 bachelor students aimed at investigating the effectiveness of Model-driven development during software maintenance and evolution activities. The tool used in the experiment is UniMod, a specific implementation of executable UML. Preliminary results indicate a relevant shortening of time with no significant impact on correctness, gained through the use of UniMod instead of conventional programming (i.e., code-centric programming).

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.

In this paper, we present and discuss the results of an internal replication of a controlled experiment for assessing the effectiveness of including screen mockups when adopting Use Cases. The results of the original experiment indicate a clear improvement in terms of understandability of functional requirements when screen mockups are present with no significant impact on effort. The data analysis of the replication, conducted also in this case with undergraduate students, confirms the results of the original experiment with slight differences, thus confirming that screen mockups facilitate the understanding of requirements without influencing the effort. We also sketch here some issues related to the documentation and communication between experimenters

In order to increase stakeholders' comprehension on software requirements, Use Cases can be enhanced with screen mock-ups (i.e., GUI prototypes sketched with a special conceived graphical tool). However, the effort to write Use Cases augmented with screen mockups may increase, thus not justifying their adoption in the requirements engineering process.

This paper presents an attempt, perhaps unorthodox, at bridging the gap between the use of formal techniques and the current software engineering practices. After years of full immersion in the development and use of formal techniques, we have been led to suggest a Virtuous Cycle philosophy, better marrying the rigor of formalities to the needs and, why not, the wisdom of current practices. What we have called Well-Founded Software Development Methods is a strategy compliant with that philosophy, that essentially aims at proposing methods where the formalities provide the foundational rigor, and perhaps may inspire new techniques, but are kept hidden form the user. In a stream of papers, we have outlined an approach - a possible instantiation of a particular well-founded method - which is Model-Driven and adopts a UML notation. Here, after introducing our basic philosophy and the Well-Founded methods strategy, we outline in summary our sample approach and, as a new contribution, we show in some detail how to handle the Model-Driven Design (or Platform Independent Design) phase.

On the basis of some experience in the use of UML-based methods, we believe that a more refined and stringent structuring of the knowledge in the Requirement Specification may help the specification process and make easier the consistency checks among the various components. Thus we propose a way of structuring and representing the Requirement Specification artifacts that presents a number of novelties w.r.t. the best-known current methods. Our proposal is multiview, use case-driven and UML-based; thus also object-oriented. However, also benefitting of some earlier work, notably in the Structured Analysis, we take a rather abstract view, trying to avoid a preemptive decision on the classes structuring the system to build; that is achieved not only making a sharp distinction between business/domain modelling and the system, but also dealing with the system at the requirement level as a black box, providing only the minimal structure needed to express the interactions with the context.

Coordination via tuple spaces is a well known and accepted technique for designing distributed systems; originally introduced in Linda, it has been very recently adopted within the Java environment as an underlying mechanism of the JavaSpaces/sup TM/ technology. We explore the possibility of using such a technique in the development of systems adopting the UML notation. While tuple spaces are modelled quite naturally in UML as particular classes, state machines do not seem adequate for modelling active objects interacting via tuple spaces. Thus, we propose to extend state machines by adding transition triggers corresponding to successful and failed execution of lookup operations on a tuple space. The result is a UML profile, and thus a visual notation for modelling distributed systems based on tuple spaces.