Software errors and complexity: an empirical investigation0
Communications of the ACM
An Analysis of Several Software Defect Models
IEEE Transactions on Software Engineering
Predicting Fault Incidence Using Software Change History
IEEE Transactions on Software Engineering
Flowcharts versus program design languages: an experimental comparison
Communications of the ACM
Classification and evaluation of defects in a project retrospective
Journal of Systems and Software
Reexamining the Fault Density-Component Size Connection
IEEE Software
The effect of modularization and comments on program comprehension
ICSE '81 Proceedings of the 5th international conference on Software engineering
Generating Robust Parsers using Island Grammars
WCRE '01 Proceedings of the Eighth Working Conference on Reverse Engineering (WCRE'01)
Does The Modern Code Inspection Have Value?
ICSM '01 Proceedings of the IEEE International Conference on Software Maintenance (ICSM'01)
Identifying Reasons for Software Changes Using Historic Databases
ICSM '00 Proceedings of the International Conference on Software Maintenance (ICSM'00)
Evolution in Open Source Software: A Case Study
ICSM '00 Proceedings of the International Conference on Software Maintenance (ICSM'00)
Use of relative code churn measures to predict system defect density
Proceedings of the 27th international conference on Software engineering
MSR '05 Proceedings of the 2005 international workshop on Mining software repositories
A study of the documentation essential to software maintenance
Proceedings of the 23rd annual international conference on Design of communication: documenting & designing for pervasive information
An Experimental Investigation of Formality in UML-Based Development
IEEE Transactions on Software Engineering
Source versus Object Code Extraction for Recovering Software Architecture
WCRE '05 Proceedings of the 12th Working Conference on Reverse Engineering
Mining metrics to predict component failures
Proceedings of the 28th international conference on Software engineering
Predicting fault-prone components in a java legacy system
Proceedings of the 2006 ACM/IEEE international symposium on Empirical software engineering
The Impact of UML Documentation on Software Maintenance: An Experimental Evaluation
IEEE Transactions on Software Engineering
Towards a Theoretical Model for Software Growth
MSR '07 Proceedings of the Fourth International Workshop on Mining Software Repositories
Predicting Defects for Eclipse
PROMISE '07 Proceedings of the Third International Workshop on Predictor Models in Software Engineering
Do Code and Comments Co-Evolve? On the Relation between Source Code and Comment Changes
WCRE '07 Proceedings of the 14th Working Conference on Reverse Engineering
Automated classification of change messages in open source projects
Proceedings of the 2008 ACM symposium on Applied computing
Proceedings of the 30th international conference on Software engineering
Proceedings of the 30th international conference on Software engineering
PDL: a tool for software design
AFIPS '75 Proceedings of the May 19-22, 1975, national computer conference and exposition
Predicting faults using the complexity of code changes
ICSE '09 Proceedings of the 31st International Conference on Software Engineering
MapReduce as a general framework to support research in Mining Software Repositories (MSR)
MSR '09 Proceedings of the 2009 6th IEEE International Working Conference on Mining Software Repositories
The commenting practice of open source
Proceedings of the 24th ACM SIGPLAN conference companion on Object oriented programming systems languages and applications
Software Dependencies, Work Dependencies, and Their Impact on Failures
IEEE Transactions on Software Engineering
Hi-index | 0.00 |
When changing source code, developers sometimes update the associated comments of the code (a consistent update), while at other times they do not (an inconsistent update). Similarly, developers sometimes only update a comment without its associated code (an inconsistent update). The relationship of such comment update practices and software bugs has never been explored empirically. While some (in)consistent updates might be harmless, software engineering folklore warns of the risks of inconsistent updates between code and comments, because these updates are likely to lead to out-of-date comments, which in turn might mislead developers and cause the introduction of bugs in the future. In this paper, we study comment update practices in three large open-source systems written in C (FreeBSD and PostgreSQL) and Java (Eclipse). We find that these practices can better explain and predict future bugs than other indicators like the number of prior bugs or changes. Our findings suggest that inconsistent changes are not necessarily correlated with more bugs. Instead, a change in which a function and its comment are suddenly updated inconsistently, whereas they are usually updated consistently (or vice versa), is risky (high probability of introducing a bug) and should be reviewed carefully by practitioners.