Background: A previously proposed Design Thinking-based Requirements Elicitation Process distinguishes between internal and external empathy as distinct sub-activities. To corroborate the effectiveness of this distinction, empirical validation is required. Objective: The main goal of this paper is to present a quasi-experiment carried out with the aim of comparing the use of the Vision Canvas technique for internal empathy and the Empathy Map technique for external empathy in requirements elicitation, assessing whether and how these techniques enhance stakeholder and requirements identification during Brainstorming sessions. Method: The quasi-experiment involved 138 undergraduate Computer Engineering students at University of Sevilla. Three treatments were considered: a combination of both techniques (Vision Canvas followed by Empathy Maps), Empathy Maps alone, and a control group relying solely on Brainstorming. Results: The results revealed an improvement in stakeholder identification using empathy-based techniques, with statistically significant differences observed when these techniques were applied in combination. Additionally, the analysis showed an increase in the number of requirements ideas generated with either technique, compared to the control group. Conclusions: While these findings support the distinction between internal and external empathy in requirements elicitation, further research is necessary to determine the optimal application of these techniques across different contexts.

This article presents a proposal for validating a requirements elicitation process based on Design Thinking (PRO-RE-DT) using action research. The action research method was selected based on evidence of similar uses in software engineering, its iterative nature, and primarily for the active role of the researcher, which we consider.

Together with many success stories, promises such as the increase in production speed and the improvement in stakeholders’ collaboration have contributed to making agile a transformation in the software industry in which many companies want to take part. However, driven either by a natural and expected evolution or by contextual factors that challenge the adoption of agile methods as prescribed by their creator(s), software processes in practice mutate into hybrids over time. Are these still agile? In this article, we investigate the question: what makes a software development method agile? We present an empirical study grounded in a large-scale international survey that aims to identify software development methods and practices that improve or tame agility. Based on 556 data points, we analyze the perceived degree of agility in the implementation of standard project disciplines and its relation to used development methods and practices. Our findings suggest that only a small number of participants operate their projects in a purely traditional or agile manner (under 15 percent). That said, most project disciplines and most practices show a clear trend towards increasing degrees of agility. Compared to the methods used to develop software, the selection of practices has a stronger effect on the degree of agility of a given discipline. Finally, there are no methods or practices that explicitly guarantee or prevent agility. We conclude that agility cannot be defined solely at the process level. Additional factors need to be taken into account when trying to implement or improve agility in a software company. Finally, we discuss the field of software process-related research in the light of our findings and present a roadmap for future research.

Context: Programming courses are compulsory for most engineering degrees, but students’ performance on these courses is often not as good as expected. Programming is difficult for students to learn, given that it includes a lot of new, complex, and abstract topics. All of this has led experts to the conclusion that new teaching techniques are required if students are to be motivated and engaged in learning on programming courses. Gamification has come to be an effective technique in education in general, and is especially useful in programming courses. This motivated us to develop an open source gamified platform, called UDPiler, for use in a programming course. Objective: The main goal of this article is to obtain empirical evidence on the improvement of students’ learning performance when using UDPiler in comparison to a non-gamified compiler. Method: A quasi-experiment was performed with two groups of first-year engineering students at Diego Portales University in Chile, using a non-gamified compiler and a gamified platform, respectively. Results: The results reveal that the students obtained better marks when the gamified platform was used to learn C programming. In addition, there is statistical significance in favor of there being a positive effect on the learning performance of those students who used the gamified platform. Conclusions: The results allow us to conclude that gamification is an encouraging approach with which to teach C programming, a finding that is aligned with previous empirical studies concerning gamification on programming courses, carried out in academic contexts. Nonetheless, we are aware that further validation is also required to corroborate and strengthen the findings obtained and to investigate whether the kind of gamified elements (mechanics, dynamics, and aesthetics) used have any influence on students’ performance, among other issues that deserve further investigation and that are explained throughout this article.

Context: UML software development relies on different types of UML diagrams, which must be consistent with one another. UML Synthesis techniques suggest to generate diagram(s) from other diagram(s), thereby implicitly suggesting that input and output diagrams of the synthesis process be consistent with one another.

This paper presents the findings of a survey on the use of UML in software maintenance, carried out with 178 professionals working on software maintenance projects in 12 different countries. As part of long-term research we are carrying out to investigate the benefits of using UML in software maintenance, the main objectives of this survey are: 1) to explore whether UML diagrams are being used in software industry maintenance projects; 2) to see what UML diagrams are the most effective for software maintenance; 3) to find out what the perceived benefits of using UML diagrams are; and 4) to contextualize the kind of companies that use UML documentation in software maintenance. Some complementary results based on the way the documentation is used (whether it is UML-based or not) during software maintenance are also presented.

Context: The Unified Modeling Language (UML), with its 14 different diagram types, is the de-facto standard modeling language for object-oriented modeling and documentation. Since the various UML diagrams describe different aspects of one, and only one, software under development, they are not independent but strongly depend on each other in many ways. In other words, the UML diagrams describing a software product must be consistent. Inconsistencies between these diagrams may be a source of faults in software systems. It is therefore paramount that these inconsistencies be detected, analyzed and hopefully fixed.

Context: A Serious Game (SG) is a game for purposes other than entertainment [12]. SGs are currently in widespread use and their popularity has begun to steadily increase; their application areas now extend not only to education, but also to military, health and corporate [9] [12] sectors. SGs are of vital importance at present, as they can be a means to achieve relevant goals from both a personal and an institutional point of view. This may take place in fields as diverse as defense, education, scientific exploration, health care, emergency management, city planning, engineering, religion, and politics. The number of users of these systems grows each day, signifying that their impact is very high, and it is precisely for this reason that more extensive research on SG quality is needed.

We carried out a family of experiments to investigate whether the use of UML models produced in the requirements analysis process helps in the comprehensibility and modifiability of source code. The family consists of a controlled experiment and 3 external replications carried out with students and professionals from Italy and Spain. 86 participants with different abilities and levels of experience with UML took part. The results of the experiments were integrated through the use of meta-analysis. The results of both the individual experiments and meta-analysis indicate that UML models produced in the requirements analysis process influence neither the comprehensibility of source code nor its modifiability.

Context: UML has been the de facto standard notation for modeling object-oriented software systems since its appearance in 1997. UML diagrams are important for maintainers of a system, especially when the software was developed by a different team. These diagrams of the system are not always available, however, and are commonly recovered using Reverse Engineering (RE) techniques. When obtained through RE, UML diagrams have a high level of detail as compared to those developed in the forward design activity. Method: In this paper we report on a comparison of the attitude and performance of maintainers when using these two kinds of diagrams during the maintenance of source code. Our findings were obtained by carrying out a controlled experiment with 40 students of a Master's degree in Computer Science. Results: The results show a preference for forward design diagrams but do not display significant differences in task performance. The post-experiment survey results have led us to conclude that the subjects did not consider RE diagrams helpful; they found them difficult to understand, particularly the sequence diagrams. In the case of forward design diagrams, subjects considered sequence diagrams as useful, but they did not really employ them. Conclusions: Based on our findings, as regards performance of maintainers, there are no objective results which favor the use of one of these types of diagram in particular, i.e., UML diagrams which come from forwards design, on the one hand, and diagrams obtained from RE, on the other. Subjective opinions do, however, lead us to recommend the use of diagrams created during design. Nevertheless, we realize that the results should be considered as preliminary ones; further replications of this experiment are planned, using students and professionals, the aim being to obtain more conclusive results.

The quality of conceptual models directly affects the quality of the understanding of the application domain and the quality of the final software products that are ultimately based on them. This paper describes a systematic literature review (SLR) of peer-reviewed conference and journal articles published from 1997 through 2009 on the quality of conceptual models written in UML, undertaken to understand the state-of-the-art, and then identify any gaps in current research. Six digital libraries were searched, and 266 papers dealing specifically with the quality of UML models were identified and classified into five dimensions: type of model quality, type of evidence, type of research result, type of diagram, and research goal. The results indicate that most research focuses on semantic quality, with relatively little on semantic completeness; as such, this research examines new modeling methods vs. quality frameworks and metrics, as well as quality assurance vs. understanding quality issues. The results also indicate that more empirical research is needed to develop a theoretical understanding of conceptual model quality. The classification scheme developed in this paper can serve as a guide for both researchers and practitioners.

At present, the quality of software artefacts is an increasing concern for software development organizations. It is widely acknowledged that the quality of the software product that is finally implemented is influenced to an enormous extent by the quality of software artefacts (commonly models) that are produced throughout the software development process. Quality assessment and assurance techniques must therefore be applied from the early development stages onwards. The quality of the models is gaining even more relevance with the appearance of the Model Driven Development Model paradigm, which consists in the production of software as successive transformations of models. Although some methodologies for evaluating the quality of software artefacts do exist, all of them are isolated proposals, which focus on specific artefacts and apply specific assessment techniques. There is no generic and flexible methodology that allows the quality assessment of any kind of software artefact, regardless of type, much less a tool that supports it. When tackling this problem in this paper, we propose an integrated environment called “CQA-ENV”, consisting of a) Methodology for the continuous quality assessment of software artefacts, based on the ISO 14598 standard and other relevant proposals, 2) A set of tools that supports such methodology, which is composed of a vertical tool (CQA-Tool) that supports the methodology, along with several specific tools for the assessment of the different software artefacts. Current evaluation tools will also be able to be plugged into this generic tool. Moreover, the CQA-Tool provides a capacity for building a catalogue of assessment techniques that integrates available assessment techniques (e.g. metrics, checklists, modelling conventions, guidelines, etc.) for each software artefact. CQA-ENV can also be used by companies that offer software quality assessment services, especially for clients who are software development organisations, outsourcing software construction, thus obtaining an independent quality evaluation of the software products they acquire. Software development organisations that perform their own evaluation will be able to use it as well.

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.

The need for an explicit common terminology within Empirical Software Engineering (an ESE-Glossary of terms) was highlighted in the ISERN 2007 meeting [2]. The goal was to define a glossary of terms related to ESE based on an initial glossary published in http://lens-ese.cos.ufrj.br/wikiese. This initial glossary was built manually, based on expert knowledge. However, owing to the dynamic nature of the research works in ESE, this glossary must be dynamically updated with information extracted from the relevant documents in the research domain. Automation is, therefore, mandatory. We propose a text mining technique for the automatic extraction of the most relevant terms used in ESE documents. Our technique also provides the relationships between terms, with the degree of affinity between them. Our approach could, therefore, be useful in the improvement of the initial glossary of terms and in discovering relationships between terms.

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.

Navigability in use, defined as the efficiency, effectiveness and satisfaction with which a user navigates through the system in order to fulfil her goals under specific conditions, has a definite impact on the overall success of Web applications. This quality attribute can be measured based on the navigational model (NM) provided by Web engineering (WE) methodologies. Most of the measures currently defined for NMs are tightly coupled with particular WE methodologies, however. Furthermore, modifications to the design of the NM, carried out with the aim of improving navigability, are performed manually. Both practices have seriously hampered the reusability and adoption of proposed navigability measures and improvement techniques. In this paper, we present a Model-Driven Engineering approach to solving these problems. On the one hand, we propose a generic approach for the definition of navigability measurement models that can be integrated into any WE methodology. On the other hand, we present a model-driven improvement process for the NM design that incurs no increase in costs or in time-to-market of Web applications. This process is divided into two phases: evaluation (i.e. assessment of the model through objective measures) and evolution (i.e. transformation of the model when the measurement results do not fall inside the boundaries set by certain quality decision criteria that have been defined previously).

The complexity of software artifacts is widely believed to be an important determinant of maintenance effort. This paper conducts an experimental analysis of the impact of complexity on the maintenance of the Unified Modeling Language (UML) class diagrams. This represents an analysis of the effect of an internal quality attribute on an external quality attribute. A range of complexity metrics are proposed based on an ontological analysis of the UML language and previous research. The relative influence of these metrics on maintenance effort is then evaluated using a laboratory experiment. A within-subjects design was used, with subjects required to modify a range of UML class diagrams with different levels of complexity. Only two of the metrics emerged as significant determinants of maintenance effort: number of methods and number of associations. Together these explain around 28% of the variation in maintenance effort. While these findings are encouraging, further research is necessary to explore the ability of these metrics to predict maintenance effort. Copyright © 2005 John Wiley & Sons, Ltd.

Metrics are useful mechanisms for assuring database quality. However, it is necessary to prove the practical utility of the metrics because they must be used in real life. Consequently if the metrics are not useful from a practical point of view, they must be rejected. We present the metrics we have proposed for controlling the quality of relational databases and we present the case study developed in a Spanish enterprise aimed at discovering if the metrics are really useful in relation to the purpose for which they were designed, that is to say the control of quality.

It is generally accepted in the information system (IS) field that IS quality is highly dependent on the decisions made early in the development life cycle. The construction of conceptual data models is often an important task of this early development. Therefore, improving the quality of conceptual data models will be a major step towards the quality improvement of the IS development. Several quality frameworks for conceptual data models have been proposed, but most of them lack valid quantitative measures in order to evaluate the quality of conceptual data models in an objective way. In this article we will define measures for the structural complexity (internal attribute) of entity relationship diagrams (ERD) and use them for predicting their maintainability (external attribute). We will theoretically validate the proposed metrics following Briand et al.'s framework with the goal of demonstrating the properties that characterise each metric. We will also show how it is possible to predict each of the maintainability sub-characteristics using a prediction model generated using a novel method for induction of fuzzy rules.