Is It Dangerous to Use Version Control Histories to Study Source Code Evolution?

Negara, Stas; Vakilian, Mohsen; Chen, Nicholas; Johnson, Ralph E.; Dig, Danny

doi:10.1007/978-3-642-31057-7_5

Cited by 67 publications

(60 citation statements)

References 42 publications

(50 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…T4 She investigates the edit operations related to the construction of a class member of interest by slicing the operation history for the code appearing in a file containing the class member (intra-file mode in OperationSliceReplayer). T5 Several conventional tools including Syde [9] or CodingTracker [11] infer the corresponding AST nodes from the collected raw edits. By using these tools, she investigates only the edit operations filtered with respect to a class member of interest.…”

Section: Discussionmentioning

confidence: 99%

“…Negara et al argued that code change data using a version control system (VCS) is inadequate for code evolution research studies [11]. Instead, such studies should leverage IDEs to capture code changes online rather than inferring them from a postmortem of the snapshots stored in the VCS.…”

Section: Toolsmentioning

confidence: 99%

“…Instead, such studies should leverage IDEs to capture code changes online rather than inferring them from a postmortem of the snapshots stored in the VCS. Based on this standpoint, they developed CodingTracker [11], an Eclipse plug-in that non-intrusively collects fine-grained information about the code evolution of Java programs. It records every code edit performed by programmers.…”

Section: Toolsmentioning

confidence: 99%

“…Unfortunately, simple filtering provided by such conventional tools as Syde [9] or CodingTracker [11] fails to address the fine-grained tracking of code changes that result from the renaming, splitting, or merging of a class member or the moving or copying of a part of its body (e.g., cut-paste or copy-paste actions). For example, the construction of the method labeled with number 12 seems to have been performed in a relatively short period of time, with a total of 41 (9 + 32) edit operations.…”

Section: Motivationmentioning

confidence: 99%

“…As a result, it will facilitate programmers' tasks of reusing or modifying existing code in To assist code history exploration, change-based support has recently become available [6], [7]. For example, SpyWare [8], Syde [9], Fluorite [10], CodingTracker [11], and OperationRecorder [12] are embedded into modern integrated development environments (IDEs) and capture all of the fine-grained code changes performed on the editors provided by their respective IDEs. In addition, some of these recording tools collaborate with tools that visualize, filter, and/or replay recorded code changes [13]- [16].…”

Section: Introductionmentioning

confidence: 99%

See 4 more Smart Citations

Slicing Fine-Grained Code Change History

Maruyama

Omori

Hayashi

2016

IEICE Trans. Inf. & Syst.

View full text Add to dashboard Cite

SUMMARYChange-aware development environments can automatically record fine-grained code changes on a program and allow programmers to replay the recorded changes in chronological order. However, since they do not always need to replay all the code changes to investigate how a particular entity of the program has been changed, they often eliminate several code changes of no interest by manually skipping them in replaying. This skipping action is an obstacle that makes many programmers hesitate when they use existing replaying tools. This paper proposes a slicing mechanism that automatically removes manually skipped code changes from the whole history of past code changes and extracts only those necessary to build a particular class member of a Java program. In this mechanism, fine-grained code changes are represented by edit operations recorded on the source code of a program and dependencies among edit operations are formalized. The paper also presents a running tool that slices the operation history and replays its resulting slices. With this tool, programmers can avoid replaying nonessential edit operations for the construction of class members that they want to understand. Experimental results show that the tool offered improvements over conventional replaying tools with respect to the reduction of the number of edit operations needed to be examined and over history filtering tools with respect to the accuracy of edit operations to be replayed.

show abstract

Section: Discussionmentioning

confidence: 99%

Section: Toolsmentioning

confidence: 99%

Section: Toolsmentioning

confidence: 99%

Section: Motivationmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 3 more Smart Citations

Slicing Fine-Grained Code Change History

Maruyama

Omori

Hayashi

2016

IEICE Trans. Inf. & Syst.

View full text Add to dashboard Cite

show abstract

Context‐based approach to prioritize code smells for prefactoring

Sae-Lim

Hayashi

Saeki

2017

J Software Evolu Process

View full text Add to dashboard Cite

Existing techniques for detecting code smells (indicators of source code problems) do not consider the current context, which renders them unsuitable for developers who have a specific context, such as modules within their focus. Consequently, the developers must spend time identifying relevant smells. We propose a technique to prioritize code smells using the developers' context. Explicit data of the context are obtained using a list of issues extracted from an issue tracking system. We applied impact analysis to the list of issues and used the results to specify the context-relevant smells. Results show that our approach can provide developers with a list of prioritized code smells related to their current context. We conducted several empirical studies to investigate the characteristics of our technique and factors that might affect the ranking quality.Additionally, we conducted a controlled experiment with professional developers to evaluate our technique. The results demonstrate the effectiveness of our technique. KEYWORDScode smell, impact analysis, issue tracking system, prefactoring INTRODUCTIONCode smell, as defined by Fowler, 1-3 is an indicator of design flaws or problems in the source code. Code smells of many types are summarized as smell catalogs. [1][2][3] Code elements that are affected by code smells are recommended for improved quality because they are likely to cause difficulties in the future, as discussed in the literature, eg, making the source code more difficult to understand and maintain or increasing code components' fault-proneness. Moreover, Yamashita et al 4 found that code smells can affect important maintainability aspects. Hermans and Aivaloglou 5 conducted a controlled experiment, which revealed that code smells influence the block-based programming performance of novice programmers.Developers can improve the code by removing the code smells from the elements.Many researchers have examined factors that can introduce code smells into the system. Tufano et al 6 conducted a large-scale empirical study, which revealed that the main activities that tend to introduce code smells are implementing features and enhancing existing ones. Moreover, they found that developers with high workloads and pressure are more likely to introduce a smelly code to the system. Vale et al 7 investigated the factors that can influence code smells based on a software developer's perspective. That investigation revealed that factors such as time pressure, bad design decisions, lack of business knowledge, inexperienced developers, little time for refactoring, and low priority assigned to software quality influence the severity of smelly codes.For issue-driven software development projects, development teams tend to adopt an issue tracking system such as Jira or Bugzilla to manage their lists of issues, so-called backlogs. Such issues can be anything related to software change requests, eg, bug fixing or feature implementation.Developers apply refactoring techniques to source codes before implementing changes ...

show abstract

Clone refactoring inspection by summarizing clone refactorings and detecting inconsistent changes during software evolution

Chen

Kwon

Song

2018

J Software Evolu Process

View full text Add to dashboard Cite

It has been broadly assumed that removing code clones by refactorings would solve the problems of code duplication. Despite recent empirical studies on the benefit of refactorings, contradicting evidence shows that it is often difficult or impossible to remove clones by using standard refactoring techniques. Developers cannot easily determine which clones can be refactored or how they should be maintained scattered throughout a large code base in evolving systems. We propose pattern‐based clone refactoring inspection (PRI), a technique for managing clone refactorings. PRI summarizes refactorings of clones and detects clones that are not consistently refactored. To help developers refactor these anomalies, PRI also visualizes clone evolution and refactorings and fixes refactoring anomalies to prevent the clone group from being left in an inconsistent state. We evaluated PRI on 6 open‐source projects and showed that it identifies clone refactorings with 94.1% accuracy and detects inconsistent refactorings with 98.4% accuracy, tracking clone change histories. In a study with 10 student developers, the participants reported that flexible PRI's summarization and detection features can be valuable for novice developers to learn about refactorings to clones. These results show that PRI should improve developer productivity in inspecting clone refactorings distributed across multiple files in evolving systems.

show abstract

Is It Dangerous to Use Version Control Histories to Study Source Code Evolution?

Cited by 67 publications

References 42 publications

Slicing Fine-Grained Code Change History

Slicing Fine-Grained Code Change History

Context‐based approach to prioritize code smells for prefactoring

Clone refactoring inspection by summarizing clone refactorings and detecting inconsistent changes during software evolution

Contact Info

Product

Resources

About