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.

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.

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.

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.

Non-strict don't care functions, whose foremost representative is the ubiquitousif_then_else, play an essential role in computer science. As far as the semantics is concerned, they can be modelled by their totalizations with the appropriate use of elements representing undefinedness, as D. Scott has shown in his denotational approach. The situation is not so straightforward when we consider non-strict functions in the context of an algebraic framework; this point is discussed in the last section, where we explore the relationship between non-strict don't care and total algebras. The central part of this paper, after presenting the basic properties of the category of non-strict algebras, is an investigation of conditional algebraic specifications. It is shown that non-strict conditional specifications are equivalent to disjunctive specifications, and necessary and sufficient conditions for the existence of initial models are given. Since non-strict don't care specifications generalize both the total and the partial case, it is shown how the results for initiality can be obtained as specializations.

We propose a semantic framework for dynamic systems, which, in a sense, extends the well-known algebraic approach for modelling static data structures to the dynamic case. The framework is based on a new mathematical structure, called a d-oid, consisting of a set of instant structures and a set of dynamic operations. An instant structure is a static structure, e.g. an algebra; a dynamic operation is a transformation of instant structures with an associated point to point map, which allows us to keep track of the transformations of single objects and thus is called a tracking map. By an appropriate notion of morphism, the d-oids over a dynamic signature constitute a category. It is shown that d-oids can model object systems and support an abstract notion of possibly unique object identity; moreover, for a d-oid satisfying an identity preserving condition, there exists an essentially equivalent d-oid where the elements of instant structures are just names.