2009

• Beat Fluri, Michael Würsch, Emanuel Giger, Harald C. Gall, Analyzing the co-evolution of comments and source code, Software Quality Journal Vol. 17 (4), September 2009. (article)
  

  Source code comments are a valuable instrument to preserve design decisions and to communicate the intent of the code to programmers and maintainers. Nevertheless, commenting source code and keeping them up-to-date is often neglected for reasons of time or programmer?s obliviousness. In this paper, we investigate the question whether developers comment their code and to which extent they add comments or adapt them when they evolve the code. We present an approach to associate comments with source code entities to track their co-evolution over multiple versions. A set of heuristics are used to decide whether a comment is associated to its preceding or its succeeding source code entity. We analyzed the co-evolution of code and comments in eight different open source and closed source software systems. We found with statistical significance that (1) the relative amount of comments and source code grows at about the same rate; (2) the type of a source code entity, such as a method declaration or an if-statement, has a significant influence on whether or not it gets commented; (3) in six out of the eight systems, code and comments co-evolve in 90 percent of the cases; and (4) surprisingly, API changes and comments do not co-evolve but they are re-documented in a later revision. As a result, our approach enables a quantitative assessment of the commenting process in a software system. We can, therefore, leverage the results to provide feedback during development to increase the awareness when to add comments or when to adapt comments because of source code changes.

  
• Harald C. Gall, Beat Fluri, Martin Pinzger, Change Analysis with Evolizer and ChangeDistiller, IEEE Software Vol. 26 (1), January/February 2009. (article)
  
  
• Patrick Knab, Martin Pinzger, Beat Fluri, Harald C. Gall, Interactive Views for Analyzing Problem Reports, ICSM '09 Proceedings of the 25th International Conference on Software Maintenance 2009. (inproceedings)
  

  Issue tracking repositories contain a wealth of information for reasoning about various aspects of software development processes. In this paper, we focus on bug triaging and provide visual means to explore the effort estimation quality and the bug life-cycle of reported problems. Our approach follows the Micro/Macro reading technique and uses a combination of graphical views to investigate details of individual problem reports while maintaining the context provided by the surrounding data population. This enables the detection and detailed analysis of hidden pat- terns and facilitates the analysis of problem report outliers. In an industrial study, we use our approach in various problem report analysis scenarios and answer questions related to effort estimation and resource planning.

  

2008

• Beat Fluri, Emanuel Giger, Harald C. Gall, Discovering Patterns of Change Types, Proceedings of the 23rd International Conference on Automated Software Engineering, September 2008, IEEE Computer Society. (inproceedings)
  

  The reasons why software is changed are manyfold; new features are added, bugs have to be fixed, or the consistency of coding rules has to be re-established. Since there are many types of of source code changes we want to explore whether they appear frequently together in time and whether they describe specific development activities. We describe a semi-automated approach to discover patterns of such change types using agglomerative hierarchical clustering. We extracted source code changes of one commercial and two open-source software systems and applied the clustering. We found that change type patterns do describe development activities and affect the control flow, the exception flow, or change the API.

  
• Beat Fluri, Jonas Zuberbuehler, Harald C. Gall, Recommending Method Invocation Context Changes, Proceedings of the 1st International Workshop on Recommender Systems for Software Engineering, November 2008, ACM. (inproceedings)
  

  Our investigations of bug fixes in Eclipse showed that a significant amount of bugs were fixed by moving invocations of certain methods into the then or else-part of if-statements with similar conditions. Based on this finding, we leverage such context changes applied in the past to support developers while adding invocations of the same method. In this paper we present ChangeCommander, an Eclipse plugin that implements our approach to recommend insertions of particular if-statements before calling a method. ChangeCommander presents context change suggestions by highlighting affected method invocations in the source code and provides automated code adaptation support.

  

2007

• Beat Fluri, Assessing Changeability by Investigating the Propagation of Change Types, Proceedings of the 29th International Conference on Software Engineering, May 2007, IEEE Computer Society. (inproceedings)
  

  We propose an approach to build a changeability assessment model for source code entities. Based on this model, we will assess the changeability of evolving software systems. The changeability assessment is based on a taxonomy of more than 30 change types and a classification of these in terms of change significance levels for consecutive versions of software entities. We consider change type propagation on different levels of granularity ranging from method changes to interface and class changes. We claim that this kind of assessment is effective in pointing to potential causes of maintainability problems in evolving software systems.

  
• Beat Fluri, Michael Würsch, Martin Pinzger, Harald C. Gall, Change Distilling: Tree Differencing for Fine-Grained Source Code Change Extraction, IEEE Transactions on Software Engineering Vol. 33 (11), November 2007. (article)
  

  A key issue in software evolution analysis is the identification of particular changes that occur across several versions of a program. We present change distilling, a tree differencing algorithm for fine-grained source code change extraction. For that, we have improved the existing algorithm of Chawathe et al. for extracting changes in hierarchically structured data. Our algorithm extracts changes by finding both a match between the nodes of the compared two abstract syntax trees and a minimum edit script that can transform one tree into the other given the computed matching. As a result, we can identify fine-grained change types between program versions according to our taxonomy of source code changes. We evaluated our change distilling algorithm with a benchmark we developed that consists of 1,064 manually classified changes in 219 revisions of eight methods from three different open source projects. We achieved significant improvements in extracting types of source code changes: Our algorithm approximates the minimum edit script by 45% better than the original change extraction approach by Chawathe et al. We are able to find all occurring changes and almost reach the minimum conforming edit script, i.e., we reach a mean absolute percentage error of 34%, compared to 79% reached by the original algorithm. The paper describes both our change distilling algorithm and the results of our evaluation.

  
• Beat Fluri, Michael Würsch, Harald C. Gall, Do Code and Comments Co-Evolve? On the Relation Between Source Code and Comment Changes, Proceedings of the 14th Working Conference on Reverse Engineering, October 2007, IEEE Computer Society. (inproceedings)
  

  Comments are valuable especially for program understanding and maintenance, but do developers comment their code? To which extent do they add comments or adapt them when they evolve the code? We examine the question whether source code and associated comments are really changed together along the evolutionary history of a software system. In this paper, we describe an approach to map code and comments to observe their co-evolution over multiple versions. We investigated three open source systems (i.e., ArgoUML, Azureus, and JDT Core) and describe how comments and code co-evolved over time. Some of our findings show that: 1) newly added code|despite its growth rate|barely gets commented; 2) class and method declarations are commented most frequently but far less, for example, method calls; and 3) that 97% of comment changes are done in the same revision as the associated source code change.

  

2006

• Beat Fluri, Harald C. Gall, Classifying Change Types for Qualifying Change Couplings, Proceedings of the 9th International Conference on Program Comprehension, June 2006, IEEE Computer Society. (inproceedings)
  

  Current change history analysis approaches rely on information provided by versioning systems such as CVS. Therefore, changes are not related to particular source code entities such as classes or methods but rather to text lines added and/or removed. For analyzing whether some change coupling between source code entities is significant or only minor textual adjustments have been checked in, it is essential to reflect the changes to the source code entities. We have developed an approach for analyzing and classifying change types based on code revisions. We can differentiate between several types of changes on the method or class level and assess their significance in terms of the impact of the change types on other source code entities and whether a change may be functionality-modifying or functionality-preserving. We applied our change taxonomy to a case study and found out that in many cases large numbers of lines added and/or deleted are not accompanied by significant changes but small textual adaptations (such as indentation, etc.). Furthermore, our approach allows us to relate all change couplings to the significance of the identified change types. As a result, change couplings between code entities can be qualified and less relevant couplings can be filtered out.

  
• Reto Geiger, Beat Fluri, Harald C. Gall, Martin Pinzger, Relation of Code Clones and Change Couplings, Proceedings of the 9th International Conference of Funtamental Approaches to Software Engineering, March 2006, Springer. (inproceedings)
  

  Code clones have long been recognized as bad smells in software systems and are considered to cause maintenance problems during evolution. It is broadly assumed that the more clones two files share, the more often they have to be changed together. This relation between clones and change couplings has been postulated but neither demonstrated nor quantified yet. However, given such a relation it would simplify the identification of restructuring candidates and reduce change couplings. In this paper, we examine this relation and discuss if a correlation between code clones and change couplings can be verified. For that, we propose a framework to examine code clones and relate them to change couplings taken from release history analysis. We validated our framework with the open source project Mozilla and the results of the validation show that although the relation is statistically unverifiable it derives a reasonable amount of cases where the relation exists. Therefore, to discover clone candidates for restructuring we additionally propose a set of metrics and a visualization technique. This allows one to spot where a correlation between cloning and change coupling exists and, as a result, which files should be restructured to ease further evolution.

  

2005

• Beat Fluri, Harald C. Gall, Martin Pinzger, Fine-Grained Analysis of Change Couplings, Proceedings of the 5th International Workshop on Source Code Analysis and Manipulation, October 2005, IEEE Computer Society. (inproceedings)
  

  In software evolution analysis, many approaches analyze release history data available through versioning systems. The recent investigations of CVS data have shown that commonly committed files highlight their change couplings. However, CVS stores modifications on the basis of text but does not track structural changes, such as the insertion, removing, or modification of methods or classes. A detailed analysis whether change couplings are caused by source code couplings or by other textual modifications, such as updates in license terms, is not performed by current approaches. The focus of this paper is on adding structural change information to existing release history data. We present an approach that uses the structure compare services shipped with the Eclipse IDE to obtain the corresponding fine-grained changes between two subsequent versions of any Java class. This information supports filtering those change couplings which result from structural changes. So we can distill the causes for change couplings along releases and filter out those that are structurally relevant. The first validation of our approach with a medium-sized open source software system showed that a reasonable amount of change couplings are not caused by source code changes.

  

RDF for all publications BibTeX for all publications