Don't touch my code!: examining the effects of ownership on software quality

By Christian Bird, N. Nagappan, Brendan Murphy, Harald C. Gall, Premkumar T. Devanbu. ESEC/FSE '11, 2011

404 citations recorded by the source corpus.

Ownership is a key aspect of large-scale software development. We examine the relationship between different ownership measures and software failures in two large software projects: Windows Vista and Windows 7. We find that in all cases, measures of ownership such as the number of low-expertise developers, and the proportion of ownership for the top owner have a relationship with both pre-release faults and post-release failures. We also empirically identify reasons that low-expertise developers make changes to components and show that the removal of low-expertise contributions dramatically decreases the performance of contribution based defect prediction. Finally we provide recommendations for source code change policies and utilization of resources such as code inspections based on our results.

Subfields: Computer Science Applications, Information Systems, Software

View Paper: https://www.semanticscholar.org/paper/0ff83a2c7e1c66d03b3ddd561af28c43fae27ea0

How researchers see this paper

The researchers whose trusted networks rank it highest, strongest advocate first. Every researcher gets a different order.

In Computer Science Applications

In Information Systems

In Software

Citations in the corpus

Curating GitHub for engineered software projects (2017, background): “An example of this can be seen in the recommendations made by Bird et al. (2011) in their study regarding the effects of code ownership on the quality of software systems.”
A large scale study of programming languages and code quality in github (2014, background): “Considering software quality, for example, there are a number of well-known influential factors, including source code size [8], the number of developers [29, 3], and age/maturity [13].”
Influence apart from Adoption: How Interaction between Programming and Scientific Practices Shapes Modes of Inquiry in Four Oceanography Teams (2016, background): “In a study of software ownership (“a general term used to describe whether one person has responsibility for a software component, or if there is no one clearly responsible developer”), Bird et al demonstrate and explore the claim that “when there is no clear point of contact and the contributions t”
The impact of code review coverage and code review participation on software quality: a case study of the qt, VTK, and ITK projects (2014, background): “Since we aim to investigate the impact that code reviewing has on defect-proneness, we control for the three most common families of metrics that are known to have a relationship with defect-proneness [5, 13, 38].”
Heterogeneous Defect Prediction (2015, background): “, McCabe’s cyclomatic, lines of code, and the number of developers modifying a file, follow this defect-proneness tendency [1], [2], [6], [15], [16].”
An Empirical Comparison of Model Validation Techniques for Defect Prediction Models (2017, background): “Since we preserve the original rate of defective modules in these samples (i.e., 21 percent), our samples are of 100, 300, 500, and 1,000 modules for an EPV value of 1, 3, 5, and 10, respectively (see Section 5.2 for details on sample size generation).”
A large-scale empirical study of just-in-time quality assurance (2013, neutral): “[5].”
An empirical study of the impact of modern code review practices on software quality (2015, methodology): “component-specific expertise, are less likely to be defect-prone (Bird et al. 2011).”
How, and why, process metrics are better (2013, background): “MINOR measures the number of contributors who authored less than 5% [4] of the code in that file.”
An Exploratory Study on Self-Admitted Technical Debt (2014, result): “The number of prior commits serves as a proxy for experience and has been used in a similar manner in previous work [20], [21].”
Modern Code Review: A Case Study at Google (2017, background): “For example, a study of code ownership at Microsoft found that changes made by minor contributors should be received with more scrutiny to improve code quality [9]; we found that this concept is enforced at Google through the requirement of an approval from an owner.”
When and Why Your Code Starts to Smell Bad (and Whether the Smells Go Away) (2017, neutral): “[12], a file owner is a developer responsible for more than 75 percent of the commits performed on the file.”