Vieri del Bianco

A Case Study in COSMIC Functional Size Measurement: The Rice Cooker Revisited

UML models have been successfully used to support COSMIC-based functional size measurement. UML-based measurement is of great interest for industry, because of the popularity of the language. However, industry needs well defined, easy to learn and apply methods. It is therefore necessary to provide measurement procedures that are well defined, that require relatively little effort and that are coherent with the COSMIC measurement rules, in order to ease their adoption in enterprise environments. This paper contributes to such goal: we show how to build UML models that are easy to measure according to the COSMIC rules; we provide a case study based on the well-known example of the rice cooker; we show how the usage of UML can actually improve the practice of COSMIC measurement, by making the COSMIC measurement rules applicable in a UML context.

Combining problem frames and UML in the description of software requirements

Problem frames are a sound and convenient approach to requirements modeling. Nevertheless, they are far less popular than other less rigorous approaches. One reason is that they employ a notation that is neither very appealing nor easy to use. The problem frames notation is sufficiently different from other development languages –especially UML– to create an “impedance mismatch”: using problem frames to describe requirements does not help the transition to the design phase, makes it difficult for programmers to fully comprehend requirements, and does not favor traceability. As a consequence, problem frames are rarely adopted in software development processes employing UML as a design language. UML itself provides a linguistic support for requirements modeling, which however suffers from several limitations, especially as far as precision and formality are concerned. The goal of this paper is to combine problem frames and UML in order to both improving the linguistic support for problem frames –while preserving the underlying concepts– and to improve the UML development practice by introducing the problem frames approach, making it seamlessly applicable in the context of the familiar UML language.

Model-based functional size measurement

Function Point Analysis (FPA) is the most widely used method for measuring the size of software requirements, usually for the purpose of cost estimation. Unfortunately, FPA is affected by several drawbacks: it must be performed by specifically skilled personnel, it is expensive, and the resulting measures are subject to high variability. In order to solve - at least partially - these problems, researchers have proposed to base FP counting on UML models. However, models built without having FPA in mind hardly provide the required information at the proper detail level, so that the measures of the models tend to vary accordingly. On the contrary, building models that are suitable for FPA generally requires additional notations, skills and effort, thus partly spoiling the advantages of the approach. This paper illustrates a technique for building FPA-oriented UML models that do not need to include more information than usually required by the development process, and are easy to measure. As a result, FPA can be performed in a seamless way, while yielding reliable results. The proposed technique was validated by means of a controlled experiment and a set of pilot applications, which are also briefly described in the paper.

Quality of Open Source Software: The QualiPSo Trustworthiness Model

Trustworthiness is one of the main issues upon which the decision whether to adopt an Open-Source Software (OSS) product is based. The work described here is part of an activity that has the goals of 1) defining an adequate notion of trustworthiness of software products and artifacts and 2) identifying a number of factors that influence it. Specifically, this paper reports about the identification of the “dimensions” of trustworthiness, i.e., of the high-level qualities that software products and artefacts have to posses in order to be considered trustworthy. These dimensions are described by means of a conceptual model of trustworthiness, which comprises the representation of the factors that affect the user’s perception of trustworthiness, as well as the objective characteristics of the products that contribute to “build” trustworthi-ness. The aforementioned model is equipped with a measurement plan that de-scribes, at the operational level, how to perform the evaluation of the trustwor-thiness of OSS products. The proposed model provides the basis to build quantitative models of the trustworthiness of OSS products and artifacts that are able to explain the relationships between the (objectively observable) characteristics of OSS products and the level of trustworthiness perceived by the users of such products.

An Investigation of the Users’ Perception of OSS Quality

The quality of Open Source Software (OSS) is generally much debated. Some state that it is generally higher than closed-source counterparts, while others are more skeptical. The authors have collected the opinions of the users concerning the quality of 44 OSS products in a systematic manner, so that it is now possible to present the actual opinions of real users about the quality of OSS products. Among the results reported in the paper are: the distribution of trustworthiness of OSS based on our survey; a comparison of the trustworthiness of the surveyed products with respect to both open and closed-source competitors; the identification of the qualities that affect the perception of trustworthiness, based on rigorous statistical analysis.

The QualiSPo approach to OSS product quality evaluation

The quality of Open Source Software (OSS) is generally much debated. Some state that it is generally higher than closed-source counterparts, while others are more skeptical. In the QualiSPo project the authors addressed the problem of evaluating OSS products in a manner that is both as complete as possible and objective. To this end, a toolset and an evaluation framework are needed. The paper describes such toolset and framework, and accounts for the first evaluations that are being obtained.

Model-based early and rapid estimation of COSMIC functional size - An experimental evaluation

Context: Functional size measurement methods are widely used but have two major shortcomings: they require a complete and detailed knowledge of user requirements, and they involve relatively expensive and lengthy processes. Objective: UML is routinely used in the software industry to effectively describe software requirements in an incremental way, so UML models grow in detail and completeness through the requirements analysis phase. Here, we aim at defining the characteristics of increasingly more refined UML requirements models that support increasingly more sophisticated - hence presumably more accurate - size estimation processes. Method: We consider the COSMIC method and three alternative processes (two of which are proposed in this paper) to estimate COSMIC size measures that can be applied to UML diagrams at progressive stages of the requirements definition phase. Then, we check the accuracy of the estimates by comparing the results obtained on a set of projects to the functional size values obtained with the standard COSMIC method. Results: Our analysis shows that it is possible to write increasingly more detailed and complete UML models of user requirements that provide the data required by COSMIC size estimation methods, which in turn yield increasingly more accurate size measure estimates of the modeled software. Initial estimates are based on simple models and are obtained quickly and with little effort. The estimates increase their accuracy as models grow in completeness and detail, i.e., as the requirements definition phase progresses. Conclusion: Developers that use UML for requirements modeling can obtain an early estimation of the application size at the beginning of the development process, when only a very simple UML model has been built for the application, and can obtain increasingly more accurate size estimates while the knowledge of the product increases and UML models are refined accordingly.

Towards the integration of sysml and problem frames

Today, analysts are offered a wide set of conceptual tools for requirements enginering, including modelling languages, like UML and SysML, and methodological approaches, like Problem Frames. However, these conceptual tools, which address different needs and activities, are generally not integrated, thus making it difficult to effectively use more than one of them at a time. This paper addresses the integration of Problem Frames and SysML, by presenting how a set of well known problem frames can be represented by means of SysML. The idea is that problem frames can benefit from SysML as a powerful notation, while SysML users get a sound methodological approach, which is absent from the current proposal of SysML. The integration opens the way to a full model centric requirement analysis approach. Models favour the transition from the requirements to the design phase, hence the resulting model can be conveniently used as a starting point for design.

Towards UML-based formal specifications of component-based real-time software

UML-RT is achieving increasing popularity as a modeling language for real-time applications. Unfortunately UML-RT is not formally well defined and it is not well suited for supporting the specification stage: e.g., it does not provide native constructs to represent time and non-determinism. UML+ is an extension of UML that is formally well defined and suitable for expressing the specifications of real-time systems (e.g., the properties of a UML+ model can be formally verified). However, UML+ does not support design and development. This article addresses the translation of UML+ into UML-RT, thus posing the basis for a development framework where UML+ and UML-RT are used together, in order to remove each other’s limitations. Specifications are written using UML+, they are automatically verified by means of formal methods, and are then converted – through a semi-automatic process – in an equivalent UML-RT model that becomes the starting point for the implementation.

A Study on OSS Marketing and Communication Strategies

The goal of every open source project is to gain as many satisfied users as possible. To this end, open source software producers should focus on both product development and communication. Currently, most open source projects are mainly concerned with developing code using the most appealing technologies and introducing fancy features. On the contrary, open source software producers seem to lack good communication strategies. In this paper we describe the communication strategies adopted by three successful companies that are active in open source software development. The goal of the paper is to provide some hints that could help other open source software producers identify communication strategies that are effective in promoting their products on the market.