[P] G. Arevalo, G. Robiolo and M. M. Soler, "Traceable complexity metric from requirements to code," in Proceedings of the 2010 ACM-IEEE International Symposium on Empirical Software Engineering and Measurement, 2010, pp. 64:1-64:1.
http://dx.doi.org/10.1145/1852786.1852866
This
paper presents a methodology to detect and measure the complexity of
traceable transactions from requirements (use cases) to code (source
code) of a system.
[SP]
A. Fernandez, S. Abrahao and E. Insfran, "Towards to the validation of a
usability evaluation method for model-driven web development," in Proceedings of the 2010 ACM-IEEE International Symposium on Empirical Software Engineering and Measurement, 2010, pp. 54:1-54:4.
http://dx.doi.org/10.1145/1852786.1852855
The
challenge of developing more usable Web applications has promoted the
emergence of several usability evaluation methods. However, there is a
lack of empirically validated methods that can properly be integrated
during the early stages of Web development processes. This has motivated
us to propose a Web Usability Evaluation Method (WUEP) which can be
integrated into model-driven Web development processes. This paper
presents the first steps in the empirical validation of WUEP through a
controlled experiment. This experiment was designed in order to evaluate
the effectiveness, efficiency, perceived ease of use, and satisfaction
with WUEP in comparison to a widely-used inspection method: Heuristic
evaluation (HE). Results show that WUEP is more effective and efficient
than HE in the detection of usability problems in artifacts obtained
from a model-driven Web development process. The evaluators were also
satisfied when applying WUEP, and found it easier to use than HE.
[SP]
L. Lavazza and G. Robiolo, "Introducing the evaluation of complexity in
functional size measurement: A UML-based approach," in Proceedings of the 2010 ACM-IEEE International Symposium on Empirical Software Engineering and Measurement, 2010, pp. 25:1-25:9.
http://dx.doi.org/10.1145/1852786.1852820
Functional
Size Measures are often used for effort estimation. However, these
measures do not take into account the amount and complexity of
elaboration required, concentrating instead on the amount of data
accessed or moved. Methods for measuring the functional complexity have
been proposed, but, being based on the textual description of
requirements, are not very easy to apply. In this paper we show that
measurement-oriented UML modeling can support the measurement of both
functional size and functional complexity. We show, by means of a case
study, that it is reasonably easy to derive different types of
functional size measures, as well as complexity measures, from UML
models. We show also that it is possible to build models for effort
estimation that use the functional size and complexity measures as
independent variables.
[SP]
B. Marin, G. Giachetti, O. Pastor, T. E. J. Vos and A. Abran,
"Evaluating the usefulness of a functional size measurement procedure to
detect defects in MDD models," in Proceedings of the 2010 ACM-IEEE International Symposium on Empirical Software Engineering and Measurement, 2010, pp. 49:1-49:4.
http://dx.doi.org/10.1145/1852786.1852849
Models
are key artifacts in Model-Driven Development (MDD) methods. To
evaluate the quality of models, defect detection is considered to be a
suitable approach, which is usually applied using reading techniques.
However, new techniques are required in order to find as many defects as
possible. This paper presents a case study to evaluate the usefulness
of a Functional Size Measurement (FSM) procedure to detect defects in
models of a MDD environment. The results indicate that the FSM is useful
in finding all the defects that are related to a defect type as well as
finding different defect types than an inspection team does.
[RP] H. Qattous, P. Gray and R. Welland, "An empirical study of specification by example in a software engineering tool," in Proceedings of the 2010 ACM-IEEE International Symposium on Empirical Software Engineering and Measurement, 2010, pp. 16:1-16:10.
http://dx.doi.org/10.1145/1852786.1852808
Meta-CASE
tools offer CASE tool specialisation by enabling a designer to specify a
tool which is then generated automatically. Constraints are often used
in such meta-CASE tools for governing the syntax and semantics of model
elements and the values of their attributes. However, the constraint
definition process is complex, time-consuming and error-prone. This
paper presents an empirical study of the use of Specification by Example
(SBE), based on the well-known notion of Programming by Example (PBE),
as a user-computer interactive technique for such constraint
specification. Two constraint specification techniques have been
implemented in a meta-CASE tool a wizard that represents a conventional
form-filling technique and an SBE technique that depends on the user
providing one or more examples and the system inferring a list of
possible intended constraints. The empirical study compared the wizard
and SBE with respect to constraint definition correctness, task
completion time, and user satisfaction. Two common modelling diagrams
have been used, a State Transition Diagram and a Use Case Diagram.
Results suggest that SBE is superior to the wizard in terms of measured
criteria described above. Observations on the interaction of users with
the system and opinions of participants are also presented.
[P] F. Tomassetti, M. Torchiano and L. Bazzani, "Applying MDA to complex multi-tier enterprise architectures," in Proceedings of the 2010 ACM-IEEE International Symposium on Empirical Software Engineering and Measurement, 2010, pp. 61:1-61:1.
http://dx.doi.org/10.1145/1852786.1852863
This
work presents a few considerations on a project aimed at addressing the
complexity of multi-layer enterprise applications. The solution
encompassed the design of a complete model-driven architecture (MDA)
including all the tools needed to guarantee a productive process, with
the additional constraint of reaching this goal with a low
development-effort. During the project we collected useful knowledge to
mitigate the main risks connected to the MDA approach in the peculiar
context of a small company.
[SP]
S. Abrahao, E. Insfran, C. Gravino and G. Scanniello, "On the
effectiveness of dynamic modeling in UML: Results from an external
replication," in Proceedings of the 2009 3rd International Symposium on Empirical Software Engineering and Measurement, 2009, pp. 468-472.
http://dx.doi.org/10.1109/ESEM.2009.5316004
This
paper describes the results of an external replication of an experiment
for assessing whether the use of dynamic modeling influences the
comprehension of software requirements. The results of the original
experiment conducted in Italy did not confirm that there was a
significant difference in the comprehension of software requirements
when dynamic modeling is used. The goal of the replication was therefore
to verify these findings with a group of more experienced students at
the Universidad Politeacutecnica de Valencia (UPV) in Spain. The results
shows that the use of dynamic modeling does significantly improve the
comprehension of software requirements, thus providing evidence that
dynamic modeling facilitates the interpretation and comprehension of
requirements.
[SP]
O. Albayrak, "An experiment to observe the impact of UML diagrams on
the effectiveness of software requirements inspections," in Proceedings of the 2009 3rd International Symposium on Empirical Software Engineering and Measurement, 2009, pp. 506-510.
http://dx.doi.org/10.1109/ESEM.2009.5314229
Software
inspections aim to find defects early in the development process and
studies have found them to be effective. However, there is almost no
data available regarding the impact of UML diagram utilization in
software requirements specification documents on inspection
effectiveness. This paper addresses this issue by investigating whether
inclusion of UML diagrams impacts the effectiveness of requirements
inspection. We conducted an experiment in an academic environment with
35 subjects to empirically investigate the impact of UML diagram
inclusion on requirements inspections' effectiveness and the number of
reported defects. The results show that including UML diagrams in
requirements specification document significantly impacts the number of
reported defects, and there is no significant impact on the
effectiveness of individual inspections.
[SP]
M. Genero, J. A. Cruz-Lemus, D. Caivano, S. Abrahao, E. Insfran and J.
A. Carsi, "Does the use of stereotypes improve the comprehension of UML
sequence diagrams?" in Proceedings of the Second ACM-IEEE International Symposium on Empirical Software Engineering and Measurement, 2008, pp. 300-302.
http://dx.doi.org/10.1145/1414004.1414059
This
paper reports on a controlled experiment that investigates the
influence of stereotypes in UML sequence diagrams. The comprehension of
UML sequence diagrams with and without stereotypes is analyzed from
three different perspectives: semantic comprehension, retention and
transfer. The experiment was carried out with 77 undergraduate students
of Computer Science from the University of Bari in Italy. The results
obtained show a slight tendency in favor of the use of stereotypes in
facilitating the comprehension of UML sequence diagrams. Further
replications are needed to obtain more conclusive results.
[RP] L. A. Lavazza, V. del Bianco and C. Garavaglia, "Model-based functional size measurement," in Proceedings of the Second ACM-IEEE International Symposium on Empirical Software Engineering and Measurement, 2008, pp. 100-109.
http://dx.doi.org/10.1145/1414004.1414021
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.
[RP]
A. Nugroho and M. R. V. Chaudron, "A survey into the rigor of UML use
and its perceived impact on quality and productivity," in Proceedings of the Second ACM-IEEE International Symposium on Empirical Software Engineering and Measurement, 2008, pp. 90-99.
http://dx.doi.org/10.1145/1414004.1414020
The
UML (Unified Modeling Language) has become the de facto standard for
software modeling in the software industry. Despite its wide acceptance,
little is known about how UML is used in practice, let alone the
challenges and difficulties faced by engineers who work with this
modeling notation. In this paper, we provide empirical findings from a
survey on the use of UML amongst 80 professional software engineers. We
explore software engineers' opinions on common styles of using UML and
how they perceive the impact of using UML on productivity and quality in
software development. One of the results reveals that the impact of
using the UML on productivity is perceived mostly in the design,
analysis, and implementation phases.
[SP]
J. I. Panach, N. Condori-Fernandez, F. Valverde, N. Aquino and O.
Pastor, "Understandability measurement in an early usability evaluation
for model-driven development: An empirical study," in Proceedings of the Second ACM-IEEE International Symposium on Empirical Software Engineering and Measurement, 2008, pp. 354-356.
http://dx.doi.org/10.1145/1414004.1414080
Traditionally,
usability has been evaluated taking into account the user's
satisfaction when interacting with the software system. However, in a
Model-Driven Development (MDD) process, where conceptual models are the
main resource for software system generation, the usability can
potentially be evaluated at earlier stages. This work goes one step
further proposing that certain usability attributes, specifically
internal understandability attributes, can be measured from Conceptual
Models. This work presents an empirical study carried out to evaluate
the proposal. The goal of this study is to evaluate whether the value
measured using our proposal is related to the understandability value
perceived by the end user. From the analysis of the empirical results
obtained, several weaknesses of the proposal are stated.
[SP] R. Pretorius and D. Budgen, "A mapping study on empirical evidence related to the models and forms used in the uml," in Proceedings of the Second ACM-IEEE International Symposium on Empirical Software Engineering and Measurement, 2008, pp. 342-344.
http://dx.doi.org/10.1145/1414004.1414076
Context:
Although the Unified Modeling Language (UML) is now widely used, there
is little empirical knowledge about the effectiveness of its different
elements. Objectives: To conduct a systematic review of the literature
describing empirical studies of this paradigm. Method: We undertook a
Mapping Study of the literature, based upon electronic searching of
major digital libraries. Results: 33 papers have been identified and
classified by topic, form of study involved, and type of publication.
Conclusions: The largest group of empirical studies of the UML
concentrate on comprehension, and many key aspects have hardly been
investigated at all.
[SP]
C. Thomson, M. Holco, T. Cowling, T. Simons and G. Michaelides, "A
pilot study of comparative customer comprehension between extreme
x-machine and uml models," in Proceedings of the Second ACM-IEEE International Symposium on Empirical Software Engineering and Measurement, 2008, pp. 270-272.
http://dx.doi.org/10.1145/1414004.1414048
Many
design notations are used during software development to help the
developers better understand the required system. However they are
infrequently shown to clients, partly because developers believe that
clients don't understand them. In this study we investigate the extent
to which clients comprehend three types of diagram. Two popular UML
diagrams (activity and use case) and Extreme X-Machines diagrams (a type
of state diagram developed to support Extreme Programming) were shown
to three clients for whom we had recently delivered the software that
was represented. The clients were given some simple guidance on
interpreting them and asked to evaluate how well they understood them.
This pilot study found that all the diagrams studied seemed to be
equally well understood, but further studies are required to evaluate
their usefulness.
[P]
M. Genero, M. Piattini, S. Abrahao, E. Insfran, J. A. Carsi and I.
Ramos, "A controlled experiment for selecting transformations based on
quality attributes in the context of MDA," in Proceedings of the 1st International Symposium on Empirical Software Engineering and Measurement, 2007, pp. 498.
http://dx.doi.org/10.1109/ESEM.2007.64
In
this paper, we briefly introduce a controlled experiment to investigate
the selection of alternative transformation rules through which to
obtain UML class diagrams from a Requirements Model. The main goal of
this experiment was to determine which of the transformation rules for
structural relationships between classes (association (Al), aggregation
(A2) and association class (A3)) produces the UML class diagram that is
easiest to understand. More details about the transformations and about
the experiment are provided. We focus upon the understandability of UML
class diagrams because it is well recognized that if a model is easier
to understand it will be easier to maintain, reuse, etc.
[SP]
A. Nugroho and M. R. V. Chaudron, "A survey of the practice of design
-- code correspondence amongst professional software engineers," in Proceedings of the 1st International Symposium on Empirical Software Engineering and Measurement, 2007, pp. 467.
http://dx.doi.org/fs10.1109/ESEM.2007.69
Correspondence
between the design and the code of a system is desirable for several
purposes in software development, such as predicting properties of the
system based on the design, and for using the documentation for
understanding and maintaining the system. In this paper we report on a
study into the correspondence between the design of a software system,
represented by means of UML, and the implementation of the system. We
performed a web-based questionnaire among professional software
engineers for finding out how they deal with correspondence. The
questionnaire elicited the attitude of professional software engineers
with respect to: importance of correspondence, common practice in
maintaining correspondence and common reasons for deterioration of
correspondence. The results of the questionnaire provide a deeper
understanding of the aspects of correspondence and their importance in
practical software engineering.
[RP] B. Anda and K. Hansen, "A case study on the application of UML in legacy development," in Proceedings of the 2006 ACM/IEEE International Symposium on Empirical Software Engineering, 2006, pp. 124-133.
http://dx.doi.org/10.1145/1159733.1159754
Model-driven
development with UML is becoming a de facto standard in industry, but
although much of today's software development is about enhancing
existing systems, there is no well defined process for model-driven
development in the context of legacy systems. To ensure the relevance of
research on model driven development with UML, there is a need for
studies of actual use of UML in software development companies. As part
of a software process initiative, we conducted a case study in a large
development project where some of the development teams enhanced
existing components, while other teams developed software from scratch.
The results from this case study showed that those who applied UML in
modelling and enhancing legacy software experienced more challenges and
fewer benefits from the use of UML than did the developers who modelled
and developed new software. Overall our results show a need for better
methodological support on applying UML in legacy development.