Roberto Almeida Bittencourt

The Hybrid Technique for Object-Oriented Software Change Impact Analysis

Change impact analysis techniques that underestimate impact may cause important financial losses from the point of view of an IT services company. Thus, reducing false-negatives in these techniques is a goal with strong practical relevance. This work presents a technique that uses both static and dynamic analysis of object-oriented source code to improve resulting impact estimates in terms of recall. The technique consists of three steps: static analysis to identify structural dependencies between code entities, dynamic analysis to identify dependencies based on a succession relation derived from execution traces, and a ranking of results from both analyses that takes into account the relevance of dynamic dependencies. Evaluation was performed through prototype development and a multiple-case quantitative case study that compared our solution against a static technique and a dynamic one. Results showed that our hybrid technique improved recall between 90 and 115% compared to the static technique, and between 21.2 and 39% compared to the dynamic one.

Rapid Releases and Patch Backouts: A Software Analytics Approach

Release engineering deals with decisions that impact the daily lives of developers, testers, and users and thus contribute to a products success. Although gut feeling is important in such decisions, its increasingly important to leverage existing data, such as bug reports, source code changes, code reviews, and test results, both to support decisions and to help evaluate current practices. The exploration of software engineering data to obtain insightful information is called software analytics.

Improving Automated Mapping in Reflexion Models Using Information Retrieval Techniques

The reflexion model technique supports structural conformance checking of software systems. The scalability of the technique is limited by the requirement for developers to provide a mapping between implementation entities and high-level modules. Such mapping is usually based on regular expressions, and it must also be updated as the system evolves. Automated mapping techniques exist but are solely based on structural dependencies. In this paper, we introduce an automated mapping technique for reflexion models based on information retrieval techniques. It makes use of source code vocabulary and their similarity to the vocabulary of high-level modules. Two case studies conducted across four systems show that the nature of the module view influences which technique performs best. Results also show that combining both mapping techniques into a two step-mapping algorithm generally increases recall, while keeping precision similar to the best approach used in isolation.

Do Rapid Releases Affect Bug Reopening? A Case Study of Firefox

Large software organizations have been adopting rapid release cycles to deliver features and bug fixes earlier to their users. Because this approach reduces time for testing, it raises concerns about the effectiveness of quality assurance in this setting. In this paper, we study how the adoption of rapid release cycles impacts bug reopening rate, an indicator for the quality of the bug fixing process. To this end, we analyze thousands of bug reports from Mozilla Firefox, both before and after their adoption of rapid releases. Results suggest that the bug reopening rate of versions developed in rapid cycles was about 7% higher. Also, as a warning to the software analytics community, we report contradictory results from three attempts to answer our research question, performed with varying degrees of knowledge about the Firefox release process.

Patterns for cleaning up bug data

Bug reports provide insight about the quality of an evolving software and about its development process. Such data, however, is often incomplete and inaccurate, and thus should be cleaned before analysis. In this paper, we present patterns that help both novice and experienced data scientists to discard invalid bug data that could lead to wrong conclusions.

Open source projects in software engineering education: a mapping study

Context: It is common practice in academia to have students work with “toy” projects in software engineering (SE) courses. One way to make such courses more realistic and reduce the gap between academic courses and industry needs is getting students involved in open source projects (OSP) with faculty supervision. Objective: This study aims to summarize the literature on how OSP have been used to facilitate students’ learning of SE. Method: A systematic mapping study was undertaken by identifying, filtering and classifying primary studies using a predefined strategy. Results: 72 papers were selected and classified. The main results were: (a) most studies focused on comprehensive SE courses, although some dealt with specific areas; (b) the most prevalent approach was the traditional project method; (c) studies’ general goals were: learning SE concepts and principles by using OSP, learning open source software or both; (d) most studies tried out ideas in regular courses within the curriculum; (e) in general, students had to work with predefined projects; (f) there was a balance between approaches where instructors had either inside control or no control on the activities performed by students; (g) when learning was assessed, software artefacts, reports and presentations were the main instruments used by teachers, while surveys were widely used for students’ self-assessment; (h) most studies were published in the last seven years. Conclusions: The resulting map gives an overview of the existing initiatives in this context and shows gaps where further research can be pursued.

Patterns for extracting high level information from bug reports

Bug reports record tasks performed by users and developers while collaborating to resolve bugs. Such data can be transformed into higher level information that helps data scientists understand various aspects of the teams development process. In this paper, we present patterns that show, step by step, how to extract higher level information about software verification from bug report data.

Conformance Checking during Software Evolution

Reflexion models are a conformance checking technique between high-level models and source code. I propose three changes to improve scalability of the technique and its ease of use in the context of an evolving software development project. First, express architectural rules as design tests that may be checked in a testing framework. Second, support semi-automated changes to the mapping between source code and the model when source code changes occur. Finally, derive automated suggestions of high-level model changes based on improving software cohesion and coupling.

FLOSS in software engineering education: an update of a systematic mapping study

Context: Free/Libre/Open Source Software (FLOSS) projects have been used in Software Engineering Education (SEE) to address the need for more realistic settings that reduce the gap between software engineering (SE) courses and industry needs. A systematic mapping study (SMS) performed in 2013 structured the research area on the use of FLOSS projects in SEE. Objective: Update the 2013 SMS with studies published in the last five years, classifying and summarizing them to discuss trends and identify research gaps in the context of the use of FLOSS projects in SEE. Method: We retrieved and analyzed a set of 4132 papers published from 2013 to 2017, from which 33 papers were selected and classified. We analyzed the new results and compared them with those from the previous SMS to confirm or discover trends. Results: The updated mapping summarizes the studies published in the last five years, most of them in conferences. Our analysis confirmed trends previously observed for three facets (SE area, curriculum choice and assessment type) and discovered new trends for other facets. Conclusion: Studies report the use of FLOSS projects in regular, comprehensive SE courses. The prevalence of experience reports over solution proposals in the last five years may indicate that researchers are more concerned with the use and evaluation of existing proposals, although there are still opportunities for more empirical work based on sound educational research methods.

Being a PBL teacher in computer engineering: An interpretative phenomenological analysis

Problem-based learning (PBL) is a well-known active learning approach, and it is becoming increasingly popular in computing. The Computer Engineering undergraduate program at UEFS adopts PBL since 2003. Previous studies thoroughly describe PBL course design and practices, but there is a lack of reports about the teaching experience, i.e., how faculty live the process of teaching PBL courses. Thus, we took advantage of this PBL experience to uncover such issues. We developed an interpretative phenomenological analysis (IPA) to learn the essences of being a PBL teacher, using a qualitative research methodology. Data collection and analysis entailed semi-structured interviews with five UEFS computer engineering professors, interview transcription and memo writing, open coding, code memo writing, code grouping and abstraction, and description of essences. Results led to the following essences: 1) feedback is essential for student success; 2) PBL develops better students and professionals; 3) assessment is complex and multifaceted; 4) developing good problems is a difficult skill; 5) PBL requires strong teacher engagement and background; 6) it is essential to keep a motivating scenario; and 7) good coordination and group dynamics is required. In this paper, we describe the four first essences in detail.