skip to main content
research-article

Suboptimal Comments in Java Projects: From Independent Comment Changes to Commenting Practices

Published: 29 March 2023 Publication History

Abstract

High-quality source code comments are valuable for software development and maintenance, however, code often contains low-quality comments or lacks them altogether. We name such source code comments as suboptimal comments. Such suboptimal comments create challenges in code comprehension and maintenance. Despite substantial research on low-quality source code comments, empirical knowledge about commenting practices that produce suboptimal comments and reasons that lead to suboptimal comments are lacking. We help bridge this knowledge gap by investigating (1) independent comment changes (ICCs)—comment changes committed independently of code changes—which likely address suboptimal comments, (2) commenting guidelines, and (3) comment-checking tools and comment-generating tools, which are often employed to help commenting practice—especially to prevent suboptimal comments.
We collect 24M+ comment changes from 4,392 open-source GitHub Java repositories and find that ICCs widely exist. The ICC ratio—proportion of ICCs among all comment changes—is ~15.5%, with 98.7% of the repositories having ICC. Our thematic analysis of 3,533 randomly sampled ICCs provides a three-dimensional taxonomy for what is changed (four comment categories and 13 subcategories), how it changed (six commenting activity categories), and what factors are associated with the change (three factors). We investigate 600 repositories to understand the prevalence, content, impact, and violations of commenting guidelines. We find that only 15.5% of the 600 sampled repositories have any commenting guidelines. We provide the first taxonomy for elements in commenting guidelines: where and what to comment are particularly important. The repositories without such guidelines have a statistically significantly higher ICC ratio, indicating the negative impact of the lack of commenting guidelines. However, commenting guidelines are not strictly followed: 85.5% of checked repositories have violations. We also systematically study how developers use two kinds of tools, comment-checking tools and comment-generating tools, in the 4,392 repositories. We find that the use of Javadoc tool is negatively correlated with the ICC ratio, while the use of Checkstyle has no statistically significant correlation; the use of comment-generating tools leads to a higher ICC ratio.
To conclude, we reveal issues and challenges in current commenting practice, which help understand how suboptimal comments are introduced. We propose potential research directions on comment location prediction, comment generation, and comment quality assessment; suggest how developers can formulate commenting guidelines and enforce rules with tools; and recommend how to enhance current comment-checking and comment-generating tools.

References

[1]
Hirohisa Aman, Sousuke Amasaki, Tomoyuki Yokogawa, and Minoru Kawahara. 2018. A Doc2Vec-based assessment of comments and its application to change-prone method analysis. In 2018 25th Asia-Pacific Software Engineering Conference (APSEC). IEEE, 643–647.
[2]
androidannotations. 2019. How To Contribute Code. https://github.com/androidannotations/androidannotations/wiki/HowToContributeCode.
[3]
Apache Maven Javadoc Plugin. 2022. Apache Maven Javadoc Plugin. https://maven.apache.org/plugins/maven-javadoc-plugin/index.html.
[4]
Oliver Arafati and Dirk Riehle. 2009. The comment density of open source software code. In 2009 31st International Conference on Software Engineering-Companion Volume. IEEE, 195–198.
[5]
Nikolaos Bafatakis, Niels Boecker, Wenjie Boon, Martin Cabello Salazar, Jens Krinke, Gazi Oznacar, and Robert White. 2019. Python coding style compliance on stack overflow. In 2019 IEEE/ACM 16th International Conference on Mining Software Repositories (MSR). IEEE, 210–214.
[6]
Thomas Ball and Stephen G. Eick. 1996. Software visualization in the large. Computer 29, 4 (1996), 33–43.
[7]
Antonio Valerio Miceli Barone and Rico Sennrich. 2017. A parallel corpus of Python functions and documentation strings for automated code documentation and code generation. arXiv preprint arXiv:1707.02275.
[8]
Moritz Beller, Radjino Bholanath, Shane McIntosh, and Andy Zaidman. 2016. Analyzing the state of static analysis: A large-scale evaluation in open source software. In 2016 IEEE 23rd International Conference on Software Analysis, Evolution, and Reengineering (SANER), Vol. 1. IEEE, 470–481.
[9]
bestcommit. Git Commit Best Practices. https://gist.github.com/luismts/495d982e8c5b1a0ced4a57cf3d93cf60. (????).
[10]
Arianna Blasi, Alberto Goffi, Konstantin Kuznetsov, Alessandra Gorla, Michael D. Ernst, Mauro Pezzè, and Sergio Delgado Castellanos. 2018. Translating code comments to procedure specifications. In Proceedings of the 27th ACM SIGSOFT International Symposium on Software Testing and Analysis. 242–253.
[11]
Huanchao Chen, Yuan Huang, Zhiyong Liu, Xiangping Chen, Fan Zhou, and Xiaonan Luo. 2019. Automatically detecting the scopes of source code comments. Journal of Systems and Software 153 (2019), 45–63.
[12]
Qiuyuan Chen, Xin Xia, Han Hu, David Lo, and Shanping Li. 2021. Why my code summarization model does not work: Code comment improvement with category prediction. ACM Transactions on Software Engineering and Methodology (TOSEM) 30, 2 (2021), 1–29.
[13]
Qingying Chen and Minghui Zhou. 2018. A neural framework for retrieval and summarization of source code. In Proceedings of the 33rd ACM/IEEE International Conference on Automated Software Engineering, ASE 2018, Montpellier, France, September 3-7, 2018, Marianne Huchard, Christian Kästner, and Gordon Fraser (Eds.). ACM, 826–831. DOI:
[14]
Christian Collberg, Stephen Kobourov, Jasvir Nagra, Jacob Pitts, and Kevin Wampler. 2003. A system for graph-based visualization of the evolution of software. In Proceedings of the 2003 ACM Symposium on Software Visualization. 77–ff.
[15]
[17]
commitaosp2. 2010. Fix some more typos, remove unused imports, and remove unnecessary cast.https://github.com/aosp-mirror/platform_frameworks_base/commit/bcd573229e5ec6d59bb7931a84a2baa86e0d200a.
[18]
commitauthme. 2015. Prepare the project for javadocs. https://github.com/AuthMe/AuthMeReloaded/commit/118c79401a1a7d71102d90aba3db1bfcf4be5211.
[19]
commitazure. 2011. Removing “TODO” comments (made them issues in issue tracker). https://github.com/Azure/azure-sdk-for-java/commit/3094bd0ab56395b4a06f98270859c3bbd8c948ba.
[20]
commitcommons-math. 2011. Javadoc improvements. Made it more explicit which methods modify instance data. https://github.com/apache/commons-math/commit/9a8435f9d0b0633a76deba573c453d545baff793.
[21]
commitgit. 2016. diff: improve positioning of add/delete blocks in diffs. https://github.com/git/git/commit/433860f3d0beb0c6f205290bd16cda413148f098.
[22]
commitjavasimon. 2013. code cleaning, removed some more unnecessary javadoc inherits. https://github.com/virgo47/javasimon/commit/c3514caf2574b4f97825b1b3539cffceab8b1588.
[23]
commitjikes. 2012. RVM-962: Remove duplicated comments from the packages org.jikesrvm.com. https://github.com/JikesRVM/JikesRVM/commit/1508784d0dabb45b14788ab85187fc394fc78d0f.
[24]
commitmodcluster. 2016. JavaDoc cleanup: useless @see clauses, broken links, non-existent. https://github.com/modcluster/mod_cluster/commit/4ab47c63c336732a92686bef5cfbbfc059cc8573.
[25]
commitpinpoint. 2014. Translated comments to English. https://github.com/pinpoint-apm/pinpoint/commit/f9715c836612d8b3176ce2b4433fd27e0e890fc2.
[26]
commitplatform. 2018. MediaPlayer2: clarify sync/async for APIs. https://github.com/aosp-mirror/platform_frameworks_base/commit/d526bc3b886b4127c310f5dea0035404e28d27a2.
[27]
commitqpid. 2015. NO-JIRA: remove stale TODO that has already been taken care of. https://github.com/apache/qpid-jms/commit/eeb59e8478f426e7e8c34211feca9da828ea412e.
[28]
commitrichfaces. 2011. reformatted to follow JBoss Community conventions (RF-11019, RF-11020). https://github.com/richfaces/richfaces/commit/c7c155a8e0bc636d19848e7c7a2eeb0bbf7f786d.
[29]
commitsnappy. 2011. Fix javadoc. https://github.com/xerial/snappy-java/commit/ebf661dc745bf62639e19b964fe9fdbb5d520c81.
[30]
committomcat. 2009. Fixhttps://issues.apache.org/bugzilla/show_bug.cgi?id=48143. https://github.com/apache/tomcat/commit/c52b1bada15a9f28fccf74364c61e43bec3d1ae7.
[31]
committracecompass. 2012. Fix a pile of Javadoc warnings. https://github.com/tracecompass/tracecompass/commit/0283f7ffc576ed1b4e3c80c2614362785fdcdb7f.
[32]
committracee. 2014. #16 removes author tags since they add no value and can be inferred. https://github.com/tracee/tracee/commit/566d851e46419c9a1dba6f578f388a624dd51ec1.
[33]
commitwro4j. 2014. add a test which proves the problem. https://github.com/alexo/wro4j/commit/9d560ffd31c75221bb99f92f7bdbf063e9b1d885.
[34]
D. S. Cruzes and T. Dyba. 2011. Recommended steps for thematic synthesis in software engineering. In 2011 International Symposium on Empirical Software Engineering and Measurement. 275–284.
[35]
Sergio Cozzetti B. de Souza, Nicolas Anquetil, and Káthia M. de Oliveira. 2005. A study of the documentation essential to software maintenance. In Proceedings of the 23rd Annual International Conference on Design of Communication: Documenting & Designing for Pervasive Information. 68–75.
[36]
Danny Dig, Kashif Manzoor, Ralph Johnson, and Tien N. Nguyen. 2007. Refactoring-aware configuration management for object-oriented programs. In 29th International Conference on Software Engineering (ICSE’07). IEEE, 427–436.
[37]
Don A. Dillman, Jolene D. Smyth, and Leah Melani Christian. 2014. Internet, Phone, Mail, and Mixed-mode Surveys: The Tailored Design Method. John Wiley & Sons.
[38]
Omar Elazhary, Margaret-Anne Storey, Neil Ernst, and Andy Zaidman. 2019. Do as I do, not as I say: Do contribution guidelines match the GitHub contribution process? In ICSME.
[39]
Derar Eleyan, Abed Othman, and Amna Eleyan. 2020. Enhancing software comments readability using Flesch reading ease score. Information 11, 9 (2020), 430.
[40]
Dror G. Feitelson. 2021. “We do not appreciate being experimented on”: Developer and Researcher Views on the Ethics of Experiments on Open-Source Projects. CoRR abs/2112.13217 (2021). arXiv:2112.13217. https://arxiv.org/abs/2112.13217.
[41]
Beat Fluri, Michael Wursch, and Harald C. Gall. 2007. Do code and comments co-evolve? On the relation between source code and comment changes. In 14th Working Conference on Reverse Engineering (WCRE’07). IEEE, 70–79.
[42]
Beat Fluri, Michael Würsch, Emanuel Giger, and Harald C. Gall. 2009. Analyzing the co-evolution of comments and source code. Software Quality Journal 17, 4 (2009), 367–394.
[43]
Kai Gao, Zhixing Wang, Audris Mockus, and Minghui Zhou. 2022. On the variability of software engineering needs for deep learning: Stages, trends, and application types. IEEE Transactions on Software Engineering (2022).
[44]
Verena Geist, Michael Moser, Josef Pichler, Stefanie Beyer, and Martin Pinzger. 2020. Leveraging machine learning for software redocumentation. In 2020 IEEE 27th International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, 622–626.
[45]
gitdiff. 2022. git-diff - Show changes between commits, commit and working tree, etc. https://git-scm.com/docs/git-diff.
[46]
githublan. 2021. Github Language Stats. https://madnight.github.io/githut/#/pull_requests/2021/4.
[47]
githutinfo. 2022. GitHut - Programming Languages and GitHub. [EB/OL]. https://githut.info/. Accessed Feb. 2022.
[48]
Alberto Goffi, Alessandra Gorla, Michael D. Ernst, and Mauro Pezzè. 2016. Automatic generation of oracles for exceptional behaviors. In Proceedings of the 25th International Symposium on Software Testing and Analysis. 213–224.
[49]
Felix Grund, Shaiful Chowdhury, Nick C. Bradley, Braxton Hall, and Reid Holmes. 2021. CodeShovel: Constructing method-level source code histories. In 2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE). IEEE.
[50]
Dorsaf Haouari, Houari Sahraoui, and Philippe Langlais. 2011. How good is your comment? A study of comments in Java programs. In 2011 International Symposium on Empirical Software Engineering and Measurement. IEEE, 137–146.
[51]
Hideaki Hata, Christoph Treude, Raula Gaikovina Kula, and Takashi Ishio. 2019. 9.6 million links in source code comments: Purpose, evolution, and decay. In 2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE). IEEE, 1211–1221.
[52]
Hao He. 2019. Understanding source code comments at large-scale. In Proceedings of the ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, ESEC/SIGSOFT FSE’19, Tallinn, Estonia, August 26–30, 2019, Marlon Dumas, Dietmar Pfahl, Sven Apel, and Alessandra Russo (Eds.). ACM, 1217–1219. DOI:
[53]
Hao He, Runzhi He, Haiqiao Gu, and Minghui Zhou. 2021. A large-scale empirical study on Java library migrations: Prevalence, trends, and rationales. In ESEC/FSE’21: 29th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering, Athens, Greece, August 23–28, 2021, Diomidis Spinellis, Georgios Gousios, Marsha Chechik, and Massimiliano Di Penta (Eds.). ACM, 478–490. DOI:
[54]
Xing Hu, Ge Li, Xin Xia, David Lo, and Zhi Jin. 2018. Deep code comment generation. In Proceedings of the 26th Conference on Program Comprehension. 200–210.
[55]
Xing Hu, Ge Li, Xin Xia, David Lo, and Zhi Jin. 2020. Deep code comment generation with hybrid lexical and syntactical information. Empirical Software Engineering 25, 3 (2020), 2179–2217.
[56]
Yuan Huang, Xinyu Hu, Nan Jia, Xiangping Chen, Zibin Zheng, and Xiapu Luo. 2020. CommtPst: Deep learning source code for commenting positions prediction. Journal of Systems and Software (2020), 110754.
[57]
Yuan Huang, Shaohao Huang, Huanchao Chen, Xiangping Chen, Zibin Zheng, Xiapu Luo, Nan Jia, Xinyu Hu, and Xiaocong Zhou. 2020. Towards automatically generating block comments for code snippets. Information and Software Technology 127 (2020), 106373.
[58]
Yuan Huang, Nan Jia, Junhuai Shu, Xinyu Hu, Xiangping Chen, and Qiang Zhou. 2020. Does your code need comment?Software: Practice and Experience 50, 3 (2020), 227–245.
[59]
Walid M. Ibrahim, Nicolas Bettenburg, Bram Adams, and Ahmed E. Hassan. 2012. On the relationship between comment update practices and software bugs. Journal of Systems and Software 85, 10 (2012), 2293–2304.
[60]
Google Inc. 2020. Google C++ Style Guide. (2020). https://google.github.io/styleguide/cppguide.html.
[61]
Jautodoc. 2022. JAutodoc - Eclipse Plugin. http://jautodoc.sourceforge.net/.
[62]
Jautodocissue. 2015. Javadoc for public APIs. https://github.com/psi-probe/psi-probe/issues/540.
[63]
Zhen Ming Jiang and Ahmed E. Hassan. 2006. Examining the evolution of code comments in PostgreSQL. In Proceedings of the 2006 International Workshop on Mining Software Repositories. 179–180.
[64]
kiegroup/droolsjbpm-build-bootstrap. 2022. README.md. https://github.com/kiegroup/droolsjbpm-build-bootstrap/blob/main/README.md.
[65]
Alexander LeClair, Siyuan Jiang, and Collin McMillan. 2019. A neural model for generating natural language summaries of program subroutines. In 2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE). IEEE, 795–806.
[66]
Zhiyong Liu, Huanchao Chen, Xiangping Chen, Xiaonan Luo, and Fan Zhou. 2018. Automatic detection of outdated comments during code changes. In 2018 IEEE 42nd Annual Computer Software and Applications Conference (COMPSAC), Vol. 1. IEEE, 154–163.
[67]
Zhongxin Liu, Xin Xia, Meng Yan, and Shanping Li. 2020. Automating just-in-time comment updating. In The 35th IEEE/ACM International Conference on Automated Software Engineering. ACM.
[68]
Frederic M. Lord. 1964. The effect of random guessing on test validity. Educational and Psychological Measurement 24, 4 (1964), 745–747.
[69]
Annie Louis, Santanu Kumar Dash, Earl T. Barr, Michael D. Ernst, and Charles Sutton. 2020. Where should I comment my code? A dataset and model for predicting locations that need comments. In 2020 IEEE/ACM 42nd International Conference on Software Engineering (ICSE). IEEE.
[70]
Walid Maalej and Martin P. Robillard. 2013. Patterns of knowledge in API reference documentation. IEEE Transactions on Software Engineering 39, 9 (2013), 1264–1282.
[71]
Paul W. McBurney and Collin McMillan. 2016. An empirical study of the textual similarity between source code and source code summaries. Empirical Software Engineering 21, 1 (2016), 17–42.
[72]
Laura Moreno, Jairo Aponte, Giriprasad Sridhara, Andrian Marcus, Lori Pollock, and K. Vijay-Shanker. 2013. Automatic generation of natural language summaries for Java classes. In 2013 21st International Conference on Program Comprehension (ICPC). IEEE, 23–32.
[73]
Andrew Nesbitt and Benjamin Nickolls. 2017. Libraries.io open source repository and dependency metadata. (2017).
[74]
Tien N. Nguyen, Ethan V. Munson, and John T. Boyland. 2005. An infrastructure for development of multi-level, object-oriented configuration management services. In ICSE.
[75]
Pengyu Nie, Rishabh Rai, Junyi Jessy Li, Sarfraz Khurshid, Raymond J. Mooney, and Milos Gligoric. 2019. A framework for writing trigger-action todo comments in executable format. In Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. 385–396.
[76]
Sebastian Nielebock, Dariusz Krolikowski, Jacob Krüger, Thomas Leich, and Frank Ortmeier. 2019. Commenting source code: Is it worth it for small programming tasks?Empirical Software Engineering 24, 3 (2019), 1418–1457.
[77]
oracalguidelines. Code Conventions for the Java TM Programming Language. https://www.oracle.com/java/technologies/javase/codeconventions-contents.html. (????).
[78]
Yoann Padioleau, Lin Tan, and Yuanyuan Zhou. 2009. Listening to programmers—Taxonomies and characteristics of comments in operating system code. In 2009 IEEE 31st International Conference on Software Engineering. IEEE, 331–341.
[79]
Sebastiano Panichella, Venera Arnaoudova, Massimiliano Di Penta, and Giuliano Antoniol. 2015. Would static analysis tools help developers with code reviews? In 2015 IEEE 22nd International Conference on Software Analysis, Evolution, and Reengineering (SANER). IEEE, 161–170.
[80]
Sheena Panthaplackel, Milos Gligoric, Raymond J. Mooney, and Junyi Jessy Li. 2020. Associating natural language comment and source code entities. In The Thirty-Fourth AAAI Conference on Artificial Intelligence. 8592–8599.
[81]
Sheena Panthaplackel, Junyi Jessy Li, Milos Gligoric, and Raymond J. Mooney. 2021. Deep just-in-time inconsistency detection between comments and source code. In AAAI Conference on Artificial Intelligence. 427–435.
[82]
Sheena Panthaplackel, Pengyu Nie, Milos Gligoric, Junyi Jessy Li, and Raymond Mooney. 2020. Learning to update natural language comments based on code changes. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics. 1853–1868.
[83]
Luca Pascarella. 2018. Classifying code comments in Java mobile applications. In 2018 IEEE/ACM 5th International Conference on Mobile Software Engineering and Systems (MOBILESoft). IEEE, 39–40.
[84]
Luca Pascarella and Alberto Bacchelli. 2017. Classifying code comments in Java open-source software systems. In 2017 IEEE/ACM 14th International Conference on Mining Software Repositories (MSR). IEEE, 227–237.
[85]
Luca Pascarella, Magiel Bruntink, and Alberto Bacchelli. 2019. Classifying code comments in Java software systems. Empirical Software Engineering 24, 3 (2019), 1499–1537.
[86]
Fazle Rabbi and Md. Saeed Siddik. 2020. Detecting code comment inconsistency using siamese recurrent network. In Proceedings of the 28th International Conference on Program Comprehension. 371–375.
[87]
Pooja Rani, Suada Abukar, Nataliia Stulova, Alexandre Bergel, and Oscar Nierstrasz. 2021. Do comments follow commenting conventions? A case study in Java and Python. In 2021 IEEE 21st International Working Conference on Source Code Analysis and Manipulation (SCAM). IEEE, 165–169.
[88]
Pooja Rani, Mathias Birrer, Sebastiano Panichella, Mohammad Ghafari, and Oscar Nierstrasz. 2021. What do developers discuss about code comments? In International Working Conference on Source Code Analysis and Manipulation. to appear. http://arxiv.org/abs/2108.07648.
[89]
Pooja Rani, Sebastiano Panichella, Manuel Leuenberger, Andrea Di Sorbo, and Oscar Nierstrasz. 2021. How to identify class comment types? A multi-language approach for class comment classification. Journal of Systems and Software 181 (2021), 111047.
[90]
Pooja Rani, Sebastiano Panichella, Manuel Leuenberger, Mohammad Ghafari, and Oscar Nierstrasz. 2021. What do class comments tell us? An investigation of comment evolution and practices in Pharo Smalltalk. Empirical Software Engineering 26, 6 (2021), 1–49.
[91]
Inderjot Kaur Ratol and Martin P. Robillard. 2017. Detecting fragile comments. In 2017 32nd IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 112–122.
[92]
Sébastien Rufiange and Guy Melançon. 2014. AniMatrix: A matrix-based visualization of software evolution. In 2014 Second IEEE Working Conference on Software Visualization. IEEE, 137–146.
[93]
Yusuke Shinyama, Yoshitaka Arahori, and Katsuhiko Gondow. 2018. Analyzing code comments to boost program comprehension. In 2018 25th Asia-Pacific Software Engineering Conference (APSEC). IEEE, 325–334.
[94]
Andrew J. Simmons, Scott Barnett, Jessica Rivera-Villicana, Akshat Bajaj, and Rajesh Vasa. 2020. A large-scale comparative analysis of coding standard conformance in open-source data science projects. In Proceedings of the 14th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM). 1–11.
[95]
Edward Smith, Robert Loftin, Emerson Murphy-Hill, Christian Bird, and Thomas Zimmermann. 2013. Improving developer participation rates in surveys. In 2013 6th International Workshop on Cooperative and Human Aspects of Software Engineering (CHASE). IEEE, 89–92.
[96]
Giriprasad Sridhara, Emily Hill, Divya Muppaneni, Lori Pollock, and K. Vijay-Shanker. 2010. Towards automatically generating summary comments for Java methods. In Proceedings of the IEEE/ACM International Conference on Automated Software Engineering. 43–52.
[97]
Daniela Steidl, Benjamin Hummel, and Elmar Juergens. 2013. Quality analysis of source code comments. In 2013 21st International Conference on Program Comprehension (ICPC). IEEE, 83–92.
[98]
Margaret-Anne Storey, Jody Ryall, R. Ian Bull, Del Myers, and Janice Singer. 2008. TODO or to bug. In 2008 ACM/IEEE 30th International Conference on Software Engineering. IEEE, 251–260.
[99]
Nataliia Stulova, Arianna Blasi, Alessandra Gorla, and Oscar Nierstrasz. 2020. Towards detecting inconsistent comments in Java source code automatically. In 2020 IEEE 20th International Working Conference on Source Code Analysis and Manipulation (SCAM). IEEE, 65–69.
[100]
Supplementary Materials. Supplementary Materials. Website. (????). https://github.com/TyphoonWang/Suboptimal-Comments.
[101]
surveysample. Sample Size Formulas for our Sample Size Calculator - Creative Research Systems. https://www.surveysystem.com/sample-size-formula.htm. (????).
[102]
Lin Tan, Ding Yuan, Gopal Krishna, and Yuanyuan Zhou. 2007. /* iComment: Bugs or bad comments? */. In Proceedings of Twenty-first ACM SIGOPS Symposium on Operating Systems Principles. 145–158.
[103]
Lin Tan, Yuanyuan Zhou, and Yoann Padioleau. 2011. aComment: Mining annotations from comments and code to detect interrupt related concurrency bugs. In 2011 33rd International Conference on Software Engineering (ICSE). IEEE, 11–20.
[104]
Shin Hwei Tan, Darko Marinov, Lin Tan, and Gary T. Leavens. 2012. @tComment: Testing Javadoc comments to detect comment-code inconsistencies. In 2012 IEEE Fifth International Conference on Software Testing, Verification and Validation. IEEE, 260–269.
[105]
Xin Tan, Kai Gao, Minghui Zhou, and Li Zhang. 2022. An exploratory study of deep learning supply chain. In 2022 IEEE/ACM 44th International Conference on Software Engineering (ICSE). 86–98.
[106]
Xin Tan and Minghui Zhou. 2019. How to communicate when submitting patches: An empirical study of the Linux kernel. Proc. ACM Hum. Comput. Interact. 3, CSCW (2019), 108:1–108:26. DOI:
[107]
Xin Tan, Minghui Zhou, and Zeyu Sun. 2020. A first look at good first issues on GitHub. In ESEC/FSE’20: 28th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering, Virtual Event, USA, November 8–13, 2020, Prem Devanbu, Myra B. Cohen, and Thomas Zimmermann (Eds.). ACM, 398–409. DOI:
[108]
Sider Team. 2021. How Open-Sourced Projects use Checkstyle. [EB/OL]. https://siderlabs.com/blog/an-overview-of-checkstyle-and-how-it-is-used-in-open-sourced-projects-8dc288f65fdb/. Accessed Feb. 2021.
[109]
Gias Uddin and Martin P. Robillard. 2015. How API documentation fails. IEEE Software 32, 4 (2015), 68–75.
[110]
Carmine Vassallo, Sebastiano Panichella, Fabio Palomba, Sebastian Proksch, Andy Zaidman, and Harald C. Gall. 2018. Context is king: The developer perspective on the usage of static analysis tools. In 2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, 38–49.
[111]
Yao Wan, Zhou Zhao, Min Yang, Guandong Xu, Haochao Ying, Jian Wu, and Philip S. Yu. 2018. Improving automatic source code summarization via deep reinforcement learning. In Proceedings of the 33rd ACM/IEEE International Conference on Automated Software Engineering. 397–407.
[112]
Fengcai Wen, Csaba Nagy, Gabriele Bavota, and Michele Lanza. 2019. A large-scale empirical study on code-comment inconsistencies. In 2019 IEEE/ACM 27th International Conference on Program Comprehension (ICPC). IEEE, 53–64.
[113]
Fiorella Zampetti, Simone Scalabrino, Rocco Oliveto, Gerardo Canfora, and Massimiliano Di Penta. 2017. How open source projects use static code analysis tools in continuous integration pipelines. In 2017 IEEE/ACM 14th International Conference on Mining Software Repositories (MSR). IEEE, 334–344.
[114]
Juan Zhai, Xiangzhe Xu, Yu Shi, Minxue Pan, Shiqing Ma, Lei Xu, Weifeng Zhang, Lin Tan, and Xiangyu Zhang. 2020. CPC: Automatically classifying and propagating natural language comments via program analysis. In ICSE’20: Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering.
[115]
Jingyi Zhang, Lei Xu, and Yanhui Li. 2018. Classifying Python code comments based on supervised learning. In International Conference on Web Information Systems and Applications. Springer, 39–47.
[116]
Yuxia Zhang, Hui Liu, Xin Tan, Minghui Zhou, Zhi Jin, and Jiaxin Zhu. 2022. Turnover of companies in OpenStack: Prevalence and rationale. ACM Transactions on Software Engineering and Methodology (2022).
[117]
Yuxia Zhang, Minghui Zhou, Audris Mockus, and Zhi Jin. 2021. Companies’ participation in OSS development-An empirical study of OpenStack. IEEE Trans. Software Eng. 47, 10 (2021), 2242–2259. DOI:
[118]
Junji Zhi, Vahid Garousi-Yusifoğlu, Bo Sun, Golara Garousi, Shawn Shahnewaz, and Guenther Ruhe. 2015. Cost, benefits and quality of software development documentation: A systematic mapping. Journal of Systems and Software 99 (2015), 175–198.
[119]
Yu Zhou, Ruihang Gu, Taolue Chen, Zhiqiu Huang, Sebastiano Panichella, and Harald Gall. 2017. Analyzing APIs documentation and code to detect directive defects. In 2017 IEEE/ACM 39th International Conference on Software Engineering (ICSE). IEEE, 27–37.

Cited By

View all
  • (2024)Beyond code: Is there a difference between comments in visual and textual languages?Journal of Systems and Software10.1016/j.jss.2024.112087215(112087)Online publication date: Sep-2024

Index Terms

  1. Suboptimal Comments in Java Projects: From Independent Comment Changes to Commenting Practices

      Recommendations

      Comments

      Information & Contributors

      Information

      Published In

      cover image ACM Transactions on Software Engineering and Methodology
      ACM Transactions on Software Engineering and Methodology  Volume 32, Issue 2
      March 2023
      946 pages
      ISSN:1049-331X
      EISSN:1557-7392
      DOI:10.1145/3586025
      • Editor:
      • Mauro Pezzè
      Issue’s Table of Contents

      Publisher

      Association for Computing Machinery

      New York, NY, United States

      Publication History

      Published: 29 March 2023
      Online AM: 08 July 2022
      Accepted: 20 June 2022
      Revised: 13 June 2022
      Received: 13 December 2021
      Published in TOSEM Volume 32, Issue 2

      Permissions

      Request permissions for this article.

      Check for updates

      Author Tags

      1. Code comments
      2. software documentation
      3. coding guidelines
      4. software evolution

      Qualifiers

      • Research-article

      Funding Sources

      • National Key R&D Program of China
      • National Natural Science Foundation of China
      • US National Science Foundation

      Contributors

      Other Metrics

      Bibliometrics & Citations

      Bibliometrics

      Article Metrics

      • Downloads (Last 12 months)178
      • Downloads (Last 6 weeks)23
      Reflects downloads up to 05 Mar 2025

      Other Metrics

      Citations

      Cited By

      View all
      • (2024)Beyond code: Is there a difference between comments in visual and textual languages?Journal of Systems and Software10.1016/j.jss.2024.112087215(112087)Online publication date: Sep-2024

      View Options

      Login options

      Full Access

      View options

      PDF

      View or Download as a PDF file.

      PDF

      eReader

      View online with eReader.

      eReader

      Full Text

      View this article in Full Text.

      Full Text

      HTML Format

      View this article in HTML Format.

      HTML Format

      Figures

      Tables

      Media

      Share

      Share

      Share this Publication link

      Share on social media