Bibliography

BibTeX | PDF

Abad2018

Zahra Shakeri Hossein Abad, Oliver Karras, Kurt Schneider, Ken Barker, and Mike Bauer. Task interruption in software development projects. In Proc. International Conference on Evaluation and Assessment in Software Engineering (EASE). ACM, Jun 2018. URL: https://doi.org/10.1145/3210459.3210471, doi:10.1145/3210459.3210471.

Abdalkareem2017

Rabe Abdalkareem, Olivier Nourry, Sultan Wehaibi, Suhaib Mujahid, and Emad Shihab. Why do developers use trivial packages? an empirical case study on NPM. In Proc. European Software Engineering Conference/International Symposium on the Foundations of Software Engineering (ESEC/FSE). ACM, Aug 2017. URL: https://doi.org/10.1145/3106237.3106267, doi:10.1145/3106237.3106267.

Aghajani2019

Emad Aghajani, Csaba Nagy, Olga Lucero Vega-Marquez, Mario Linares-Vasquez, Laura Moreno, Gabriele Bavota, and Michele Lanza. Software documentation issues unveiled. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2019. URL: https://doi.org/10.1109/icse.2019.00122, doi:10.1109/icse.2019.00122.

Ajami2018

Shulamyt Ajami, Yonatan Woodbridge, and Dror G. Feitelson. Syntax, predicates, idioms—what really affects code complexity? Empirical Software Engineering, 24(1):287–328, Jun 2018. URL: https://doi.org/10.1007/s10664-018-9628-3, doi:10.1007/s10664-018-9628-3.

Akerblom2016

Beatrice Åkerblom and Tobias Wrigstad. Measuring polymorphism in Python programs. ACM SIGPLAN Notices, 51(2):114–128, May 2016. URL: https://doi.org/10.1145/2936313.2816717, doi:10.1145/2936313.2816717.

AlencarDaCosta2017

Daniel Alencar da Costa, Shane McIntosh, Christoph Treude, Uirá Kulesza, and Ahmed E. Hassan. The impact of rapid release cycles on the integration delay of fixed issues. Empirical Software Engineering, 23(2):835–904, Nov 2017. URL: https://doi.org/10.1007/s10664-017-9548-7, doi:10.1007/s10664-017-9548-7.

AlencarDaCosta2023

Daniel Alencar da Costa, Natalie Grattan, Nigel Stanger, and Sherlock A. Licorish. Studying the characteristics of SQL-related development tasks: an empirical study. 2023. arXiv:2301.10315.

Ali2020

Rao Hamza Ali, Chelsea Parlett-Pelleriti, and Erik Linstead. Cheating death: a statistical survival analysis of publicly available Python projects. In Proc. International Conference on Mining Software Repositories (MSR). ACM, Jun 2020. URL: https://doi.org/10.1145/3379597.3387511, doi:10.1145/3379597.3387511.

Alkhabaz2021

Ridha Alkhabaz, Seth Poulsen, Mei Chen, and Abdussalam Alawini. Insights from student solutions to MongoDB homework problems. In Proc. Conference on Innovation and Technology in Computer Science Education (ITiCSE). ACM, Jun 2021. URL: https://doi.org/10.1145/3430665.3456308, doi:10.1145/3430665.3456308.

Almeida2017

Daniel A. Almeida, Gail C. Murphy, Greg Wilson, and Mike Hoye. Do software developers understand open source licenses? In Proc. International Conference on Program Comprehension (ICPC). IEEE, May 2017. URL: https://doi.org/10.1109/icpc.2017.7, doi:10.1109/icpc.2017.7.

AlOmar2022

Eman Abdullah AlOmar, Moataz Chouchen, Mohamed Wiem Mkaouer, and Ali Ouni. Code review practices for refactoring changes: an empirical study on OpenStack. 2022. arXiv:2203.14404.

AlSubaihin2021

Afnan A. Al-Subaihin, Federica Sarro, Sue Black, Licia Capra, and Mark Harman. App store effects on software engineering practices. IEEE Transactions on Software Engineering, 47(2):300–319, Feb 2021. URL: https://doi.org/10.1109/tse.2019.2891715, doi:10.1109/tse.2019.2891715.

Alsuhaibani2022

Reem S. Alsuhaibani, Christian D. Newman, Michael J. Decker, Michael L. Collard, and Jonathan I. Maletic. An approach to automatically assess method names. In Proceedings of the 30th IEEE/ACM International Conference on Program Comprehension. ACM, May 2022. URL: https://doi.org/10.1145/3524610.3527780, doi:10.1145/3524610.3527780.

Altadmri2015

Amjad Altadmri and Neil C. C. Brown. 37 million compilations: investigating novice programming mistakes in large-scale student data. In Proc. Technical Symposium on Computer Science Education (SIGCSE). ACM, Feb 2015. URL: https://doi.org/10.1145/2676723.2677258, doi:10.1145/2676723.2677258.

AltmayerPizzorno2023

Juan Altmayer Pizzorno and Emery D Berger. Slipcover: near zero-overhead code coverage for python. 2023. arXiv:2305.02886.

Ameller2012

David Ameller, Claudia Ayala, Jordi Cabot, and Xavier Franch. How do software architects consider non-functional requirements: an exploratory study. In Proc. International Requirements Engineering Conference (RE). IEEE, Sep 2012. URL: https://doi.org/10.1109/re.2012.6345838, doi:10.1109/re.2012.6345838.

Ames2018

Morgan G. Ames. Hackers, computers, and cooperation: a critical history of logo and constructionist learning. Proceedings of the ACM on Human-Computer Interaction, 2(CSCW):1–19, Nov 2018. URL: https://doi.org/10.1145/3274287, doi:10.1145/3274287.

Anda2009

B.C.D. Anda, D.I.K. Sjøberg, and Audris Mockus. Variability and reproducibility in software engineering: a study of four companies that developed the same system. IEEE Transactions on Software Engineering, 35(3):407–429, May 2009. URL: https://doi.org/10.1109/tse.2008.89, doi:10.1109/tse.2008.89.

Apel2011

Sven Apel, Jörg Liebig, Benjamin Brandl, Christian Lengauer, and Christian Kästner. Semistructured merge: rethinking merge in revision control systems. In Proc. European Software Engineering Conference/International Symposium on the Foundations of Software Engineering (ESEC/FSE). ACM Press, 2011. URL: https://doi.org/10.1145/2025113.2025141, doi:10.1145/2025113.2025141.

Aranda2009

Jorge Aranda and Gina Venolia. The secret life of bugs: going past the errors and omissions in software repositories. In Proc. International Conference on Software Engineering (ICSE). IEEE, 2009. URL: https://doi.org/10.1109/icse.2009.5070530, doi:10.1109/icse.2009.5070530.

Aurora2019

Valerie Aurora and Mary Gardiner. How to Respond to Code of Conduct Reports. Frame Shift Consulting LLC, version 1.1 edition, 2019. ISBN 9781386922575.

Bafatakis2019

Nikolaos Bafatakis, Niels Boecker, Wenjie Boon, Martin Cabello Salazar, Jens Krinke, Gazi Oznacar, and Robert White. Python coding style compliance on stack overflow. In Proc. International Conference on Mining Software Repositories (MSR). IEEE, May 2019. URL: https://doi.org/10.1109/msr.2019.00042, doi:10.1109/msr.2019.00042.

Balachandran2013

Vipin Balachandran. Reducing human effort and improving quality in peer code reviews using automatic static analysis and reviewer recommendation. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2013. URL: https://doi.org/10.1109/icse.2013.6606642, doi:10.1109/icse.2013.6606642.

Baltes2020

Sebastian Baltes, George Park, and Alexander Serebrenik. Is 40 the new 60? how popular media portrays the employability of older software developers. IEEE Software, 37(6):26–31, Nov 2020. URL: https://doi.org/10.1109/ms.2020.3014178, doi:10.1109/ms.2020.3014178.

Bao2021

Lingfeng Bao, Xin Xia, David Lo, and Gail C. Murphy. A large scale study of long-time contributor prediction for GitHub projects. IEEE Transactions on Software Engineering, 47(6):1277–1298, Jun 2021. URL: https://doi.org/10.1109/tse.2019.2918536, doi:10.1109/tse.2019.2918536.

Barbosa2014

Eiji Adachi Barbosa, Alessandro Garcia, and Simone Diniz Junqueira Barbosa. Categorizing faults in exception handling: a study of open source projects. In Proc. Brazilian Symposium on Software Engineering (BSSE). IEEE, Sep 2014. URL: https://doi.org/10.1109/sbes.2014.19, doi:10.1109/sbes.2014.19.

Barik2017

Titus Barik, Justin Smith, Kevin Lubick, Elisabeth Holmes, Jing Feng, Emerson Murphy-Hill, and Chris Parnin. Do developers read compiler error messages? In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2017. URL: https://doi.org/10.1109/icse.2017.59, doi:10.1109/icse.2017.59.

Barik2018

Titus Barik, Denae Ford, Emerson Murphy-Hill, and Chris Parnin. How should compilers explain problems to developers? In Proc. European Software Engineering Conference/International Symposium on the Foundations of Software Engineering (ESEC/FSE). ACM, Oct 2018. URL: https://doi.org/10.1145/3236024.3236040, doi:10.1145/3236024.3236040.

Barke2019

Helena Barke and Lutz Prechelt. Role clarity deficiencies can wreck agile teams. PeerJ Computer Science, 5:e241, Dec 2019. URL: https://doi.org/10.7717/peerj-cs.241, doi:10.7717/peerj-cs.241.

Barnett2011

Mike Barnett, Manuel Fähndrich, K. Rustan M. Leino, Peter Müller, Wolfram Schulte, and Herman Venter. Specification and verification: the Spec# experience. Communications of the ACM, 54(6):81–91, Jun 2011. URL: https://doi.org/10.1145/1953122.1953145, doi:10.1145/1953122.1953145.

Barr2012

Earl T. Barr, Christian Bird, Peter C. Rigby, Abram Hindle, Daniel M. German, and Premkumar Devanbu. Cohesive and isolated development with branches. In Proc. International Conference on Fundamental Approaches to Software Engineering (FASE), 316–331. Springer Berlin Heidelberg, 2012. URL: https://doi.org/10.1007/978-3-642-28872-2_22, doi:10.1007/978-3-642-28872-2_22.

Barzilay2011

Ohad Barzilay. Example embedding. In Proc. Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software (ONWARD). ACM Press, 2011. URL: https://doi.org/10.1145/2089131.2089135, doi:10.1145/2089131.2089135.

Basak2023

Setu Kumar Basak, Lorenzo Neil, Bradley Reaves, and Laurie Williams. What challenges do developers face about checked-in secrets in software artifacts? 2023. arXiv:2301.12377.

Beck2011

Fabian Beck and Stephan Diehl. On the congruence of modularity and code coupling. In Proc. European Software Engineering Conference/International Symposium on the Foundations of Software Engineering (ESEC/FSE). ACM Press, 2011. URL: https://doi.org/10.1145/2025113.2025162, doi:10.1145/2025113.2025162.

Becker2019

Brett A. Becker, Paul Denny, Raymond Pettit, Durell Bouchard, Dennis J. Bouvier, Brian Harrington, Amir Kamil, Amey Karkare, Chris McDonald, Peter-Michael Osera, Janice L. Pearce, and James Prather. Compiler error messages considered unhelpful. In Proc. Conference on Innovation and Technology in Computer Science Education (ITiCSE). ACM, Dec 2019. URL: https://doi.org/10.1145/3344429.3372508, doi:10.1145/3344429.3372508.

Begel2014

Andrew Begel and Thomas Zimmermann. Analyze this! 145 questions for data scientists in software engineering. In Proc. International Conference on Software Engineering (ICSE). ACM, May 2014. URL: https://doi.org/10.1145/2568225.2568233, doi:10.1145/2568225.2568233.

Behroozi2019

Mahnaz Behroozi, Chris Parnin, and Titus Barik. Hiring is broken: what do developers say about technical interviews? In Symposium on Visual Languages and Human-Centric Computing (VL/HCC). IEEE, Oct 2019. URL: https://doi.org/10.1109/vlhcc.2019.8818836, doi:10.1109/vlhcc.2019.8818836.

Behroozi2020

Mahnaz Behroozi, Shivani Shirolkar, Titus Barik, and Chris Parnin. Debugging hiring: what went right and what went wrong in the technical interview process. In Proc. International Conference on Software Engineering (ICSE). ACM, 2020. URL: https://doi.org/10.1145/3377815.3381372, doi:10.1145/3377815.3381372.

Beller2015

Moritz Beller, Georgios Gousios, Annibale Panichella, and Andy Zaidman. When, how, and why developers (do not) test in their IDEs. In Proc. European Software Engineering Conference/International Symposium on the Foundations of Software Engineering (ESEC/FSE). ACM, Aug 2015. URL: https://doi.org/10.1145/2786805.2786843, doi:10.1145/2786805.2786843.

Beller2019

Moritz Beller, Georgios Gousios, Annibale Panichella, Sebastian Proksch, Sven Amann, and Andy Zaidman. Developer testing in the IDE: patterns, beliefs, and behavior. IEEE Transactions on Software Engineering, 45(3):261–284, Mar 2019. URL: https://doi.org/10.1109/tse.2017.2776152, doi:10.1109/tse.2017.2776152.

BenAri2011

Mordechai Ben-Ari, Roman Bednarik, Ronit Ben-Bassat Levy, Gil Ebel, Andrés Moreno, Niko Myller, and Erkki Sutinen. A decade of research and development on program animation: the Jeliot experience. Journal of Visual Languages & Computing, 22(5):375–384, Oct 2011. URL: https://doi.org/10.1016/j.jvlc.2011.04.004, doi:10.1016/j.jvlc.2011.04.004.

Beniamini2017

Gal Beniamini, Sarah Gingichashvili, Alon Klein Orbach, and Dror G. Feitelson. Meaningful identifier names: the case of single-letter variables. In Proc. International Conference on Program Comprehension (ICPC). IEEE, May 2017. URL: https://doi.org/10.1109/icpc.2017.18, doi:10.1109/icpc.2017.18.

Bettenburg2008

Nicolas Bettenburg, Sascha Just, Adrian Schröter, Cathrin Weiss, Rahul Premraj, and Thomas Zimmermann. What makes a good bug report? In Proc. International Symposium on Foundations of Software Engineering/International Symposium on the Foundations of Software Engineering (SIGSOFT/FSE). ACM Press, 2008. URL: https://doi.org/10.1145/1453101.1453146, doi:10.1145/1453101.1453146.

Bird2011

Christian Bird, Nachiappan Nagappan, Brendan Murphy, Harald Gall, and Premkumar Devanbu. Don't touch my code!: examining the effects of ownership on software quality. In Proc. International Symposium on Foundations of Software Engineering/International Symposium on the Foundations of Software Engineering (SIGSOFT/FSE). ACM Press, 2011. URL: https://doi.org/10.1145/2025113.2025119, doi:10.1145/2025113.2025119.

Birillo2023

Anastasiia Birillo, Elizaveta Artser, Yaroslav Golubev, Maria Tigina, Hieke Keuning, Nikolay Vyahhi, and Timofey Bryksin. Detecting code quality issues in pre-written templates of programming tasks in online courses. 2023. arXiv:2304.12376.

Bluedorn1999

Allen C. Bluedorn, Daniel B. Turban, and Mary Sue Love. The effects of stand-up and sit-down meeting formats on meeting outcomes. Journal of Applied Psychology, 84(2):277–285, 1999. URL: https://doi.org/10.1037/0021-9010.84.2.277, doi:10.1037/0021-9010.84.2.277.

Bogart2021

Chris Bogart, Christian Kästner, James Herbsleb, and Ferdian Thung. When and how to make breaking changes. ACM Transactions on Software Engineering and Methodology, 30(4):1–56, Jul 2021. URL: https://doi.org/10.1145/3447245, doi:10.1145/3447245.

Bogomolov2021

Egor Bogomolov, Vladimir Kovalenko, Yurii Rebryk, Alberto Bacchelli, and Timofey Bryksin. Authorship attribution of source code: a language-agnostic approach and applicability in software engineering. In Proc. European Software Engineering Conference/International Symposium on the Foundations of Software Engineering (ESEC/FSE). ACM, Aug 2021. URL: https://doi.org/10.1145/3468264.3468606, doi:10.1145/3468264.3468606.

Borle2017

Neil C. Borle, Meysam Feghhi, Eleni Stroulia, Russell Greiner, and Abram Hindle. Analyzing the effects of test driven development in GitHub. Empirical Software Engineering, 23(4):1931–1958, Nov 2017. URL: https://doi.org/10.1007/s10664-017-9576-3, doi:10.1007/s10664-017-9576-3.

Brown2018

Neil C. C. Brown, Amjad Altadmri, Sue Sentance, and Michael Kölling. Blackbox, five years on: an evaluation of a large-scale programming data collection project. In Proc. Conference on International Computing Education Research (ICER). ACM, Aug 2018. URL: https://doi.org/10.1145/3230977.3230991, doi:10.1145/3230977.3230991.

Brun2011

Yuriy Brun, Reid Holmes, Michael D. Ernst, and David Notkin. Proactive detection of collaboration conflicts. In Proc. International Symposium on Foundations of Software Engineering/International Symposium on the Foundations of Software Engineering (SIGSOFT/FSE). ACM Press, 2011. URL: https://doi.org/10.1145/2025113.2025139, doi:10.1145/2025113.2025139.

Businge2022

John Businge, Moses Openja, Sarah Nadi, and Thorsten Berger. Reuse and maintenance practices among divergent forks in three software ecosystems. Empirical Software Engineering, Mar 2022. URL: https://doi.org/10.1007/s10664-021-10078-2, doi:10.1007/s10664-021-10078-2.

Butler2019

Simon Butler, Jonas Gamalielsson, Bjorn Lundell, Christoffer Brax, Johan Sjoberg, Anders Mattsson, Tomas Gustavsson, Jonas Feist, and Erik Lonroth. On company contributions to community open source software projects. IEEE Transactions on Software Engineering, pages 1–1, 2019. URL: https://doi.org/10.1109/tse.2019.2919305, doi:10.1109/tse.2019.2919305.

Campos2017

Eduardo Cunha Campos and Marcelo de Almeida Maia. Common bug-fix patterns: a large-scale observational study. In Proc. International Symposium on Empirical Software Engineering and Measurement (ESEM). IEEE, Nov 2017. URL: https://doi.org/10.1109/esem.2017.55, doi:10.1109/esem.2017.55.

CardosoPereira2023

Isadora Cardoso-Pereira, Geraldo Gomes, Danilo Monteiro Ribeiro, Alberto de Souza, Danilo Lucena, and Gustavo Pinto. Supporting the careers of developers with disabilities: lessons from Zup Innovation. 2023. arXiv:2303.05429.

Chen2016

Tse-Hsun Chen, Weiyi Shang, Jinqiu Yang, Ahmed E. Hassan, Michael W. Godfrey, Mohamed Nasser, and Parminder Flora. An empirical study on the practice of maintaining object-relational mapping code in Java systems. In Proc. International Conference on Mining Software Repositories (MSR). ACM, May 2016. URL: https://doi.org/10.1145/2901739.2901758, doi:10.1145/2901739.2901758.

Cherubini2007

Mauro Cherubini, Gina Venolia, Rob DeLine, and Amy J. Ko. Let's go to the whiteboard: how and why software developers use drawings. In Proc. Conference on Human Factors in Computing Systems (HFCS). ACM, Apr 2007. URL: https://doi.org/10.1145/1240624.1240714, doi:10.1145/1240624.1240714.

Chong2007

Jan Chong and Tom Hurlbutt. The social dynamics of pair programming. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2007. URL: https://doi.org/10.1109/icse.2007.87, doi:10.1109/icse.2007.87.

Cinneide2012

Mel Ó Cinnéide, Laurence Tratt, Mark Harman, Steve Counsell, and Iman Hemati Moghadam. Experimental assessment of software metrics using automated refactoring. In Proc. International Symposium on Empirical Software Engineering and Measurement (ESEM). ACM Press, 2012. URL: https://doi.org/10.1145/2372251.2372260, doi:10.1145/2372251.2372260.

Codoban2015

Mihai Codoban, Sruti Srinivasa Ragavan, Danny Dig, and Brian Bailey. Software history under the lens: a study on why and how developers examine it. In Proc. International Conference on Software Maintenance (ICSM). IEEE, Sep 2015. URL: https://doi.org/10.1109/icsm.2015.7332446, doi:10.1109/icsm.2015.7332446.

Coelho2016

Roberta Coelho, Lucas Almeida, Georgios Gousios, Arie van Deursen, and Christoph Treude. Exception handling bug hazards in Android. Empirical Software Engineering, 22(3):1264–1304, Aug 2016. URL: https://doi.org/10.1007/s10664-016-9443-7, doi:10.1007/s10664-016-9443-7.

Costa2019

Diego Elias Costa, Cor-Paul Bezemer, Philip Leitner, and Artur Andrzejak. What's wrong with my benchmark results? studying bad practices in JMH benchmarks. IEEE Transactions on Software Engineering, pages 1–1, 2019. URL: https://doi.org/10.1109/tse.2019.2925345, doi:10.1109/tse.2019.2925345.

Costa2022

Keila Costa, Ronivaldo Ferreira, Gustavo Pinto, Marcelo d'Amorim, and Breno Miranda. Test flakiness across programming languages. IEEE Transactions on Software Engineering, pages 1–14, 2022. URL: https://doi.org/10.1109/tse.2022.3208864, doi:10.1109/tse.2022.3208864.

CruzLemus2009

José A. Cruz-Lemus, Marcela Genero, M. Esperanza Manso, Sandro Morasca, and Mario Piattini. Assessing the understandability of UML statechart diagrams with composite states—a family of empirical studies. Empirical Software Engineering, 14(6):685–719, Feb 2009. URL: https://doi.org/10.1007/s10664-009-9106-z, doi:10.1007/s10664-009-9106-z.

Dabbish2012

Laura Dabbish, Colleen Stuart, Jason Tsay, and Jim Herbsleb. Social coding in GitHub: transparency and collaboration in an open software repository. In Proc. Conference on Computer Supported Cooperative Work (CSCW). ACM Press, 2012. URL: https://doi.org/10.1145/2145204.2145396, doi:10.1145/2145204.2145396.

Dagenais2010

Barthélémy Dagenais and Martin P. Robillard. Creating and evolving developer documentation. In Proc. International Symposium on the Foundations of Software Engineering (FSE). ACM Press, 2010. URL: https://doi.org/10.1145/1882291.1882312, doi:10.1145/1882291.1882312.

Dang2012

Yingnong Dang, Rongxin Wu, Hongyu Zhang, Dongmei Zhang, and Peter Nobel. ReBucket: a method for clustering duplicate crash reports based on call stack similarity. In Proc. International Conference on Software Engineering (ICSE). IEEE, Jun 2012. URL: https://doi.org/10.1109/icse.2012.6227111, doi:10.1109/icse.2012.6227111.

Danilova2021

Anastasia Danilova, Alena Naiakshina, Stefan Horstmann, and Matthew Smith. Do you really code? designing and evaluating screening questions for online surveys with programmers. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2021. URL: https://doi.org/10.1109/icse43902.2021.00057, doi:10.1109/icse43902.2021.00057.

Davis2019

James C. Davis, Louis G. Michael IV, Christy A. Coghlan, Francisco Servant, and Dongyoon Lee. Why aren't regular expressions a lingua franca? An empirical study on the re-use and portability of regular expressions. In Proc. European Software Engineering Conference/International Symposium on the Foundations of Software Engineering (ESEC/FSE). ACM, Aug 2019. URL: https://doi.org/10.1145/3338906.3338909, doi:10.1145/3338906.3338909.

Decan2021a

Alexandre Decan and Tom Mens. Lost in zero space—an empirical comparison of 0.y.z releases in software package distributions. Science of Computer Programming, 208:102656, Aug 2021. URL: https://doi.org/10.1016/j.scico.2021.102656, doi:10.1016/j.scico.2021.102656.

Decan2021b

Alexandre Decan and Tom Mens. What do package dependencies tell us about semantic versioning? IEEE Transactions on Software Engineering, 47(6):1226–1240, Jun 2021. URL: https://doi.org/10.1109/tse.2019.2918315, doi:10.1109/tse.2019.2918315.

DeKoven2019

Louis F. DeKoven, Audrey Randall, Ariana Mirian, Gautam Akiwate, Ansel Blume, Lawrence K. Saul, Aaron Schulman, Geoffrey M. Voelker, and Stefan Savage. Measuring security practices and how they impact security. In Proceedings of the Internet Measurement Conference. ACM, Oct 2019. URL: https://doi.org/10.1145/3355369.3355571, doi:10.1145/3355369.3355571.

DeLucia2009

Andrea De Lucia, Carmine Gravino, Rocco Oliveto, and Genoveffa Tortora. An experimental comparison of ER and UML class diagrams for data modelling. Empirical Software Engineering, 15(5):455–492, Dec 2009. URL: https://doi.org/10.1007/s10664-009-9127-7, doi:10.1007/s10664-009-9127-7.

Demaine2023

Erik D. Demaine and Martin L. Demaine. Every author as first author. 2023. arXiv:2304.01393.

DePadua2018

Guilherme B. de Pádua and Weiyi Shang. Studying the relationship between exception handling practices and post-release defects. In Proc. International Conference on Mining Software Repositories (MSR). ACM, May 2018. URL: https://doi.org/10.1145/3196398.3196435, doi:10.1145/3196398.3196435.

DeSouzaSantos2023

Ronnie de Souza Santos, Brody Stuart-Verner, and Cleyton Magalhães. What do transgender software professionals say about a career in the software industry? IEEE Software, pages 1–6, 2023. URL: https://doi.org/10.1109/ms.2023.3257743, doi:10.1109/ms.2023.3257743.

Dilhara2023

Malinda Dilhara, Danny Dig, and Ameya Ketkar. PYEVOLVE: automating frequent code changes in Python ML systems. https://danny.cs.colorado.edu/papers/PyEvolve_ICSE2023.pdf, 2023.

Dorner2023

Michael Dorner, Maximilian Capraro, Oliver Treidler, Tom-Eric Kunz, Darja Šmite, Ehsan Zabardast, Daniel Mendez, and Krzysztof Wnuk. Taxing collaborative software engineering. 2023. arXiv:2304.06539.

Durieux2020

Thomas Durieux, Claire Le Goues, Michael Hilton, and Rui Abreu. Empirical study of restarted and flaky builds on travis CI. In Proc. International Conference on Mining Software Repositories (MSR). ACM, Jun 2020. URL: https://doi.org/10.1145/3379597.3387460, doi:10.1145/3379597.3387460.

Dzidek2008

W.J. Dzidek, E. Arisholm, and L.C. Briand. A realistic empirical evaluation of the costs and benefits of UML in software maintenance. IEEE Transactions on Software Engineering, 34(3):407–432, May 2008. URL: https://doi.org/10.1109/tse.2008.15, doi:10.1109/tse.2008.15.

Eghbal2020

Nadia Eghbal. Working in Public: The Making and Maintenance of Open Source Software. Stripe Press, 2020. ISBN 9780578675862.

Eichberg2015

Michael Eichberg, Ben Hermann, Mira Mezini, and Leonid Glanz. Hidden truths in dead software paths. In Proc. International Symposium on the Foundations of Software Engineering (FSE). ACM, Aug 2015. URL: https://doi.org/10.1145/2786805.2786865, doi:10.1145/2786805.2786865.

ElEmam2001

K. El Emam, S. Benlarbi, N. Goel, and S.N. Rai. The confounding effect of class size on the validity of object-oriented metrics. IEEE Transactions on Software Engineering, 27(7):630–650, Jul 2001. URL: https://doi.org/10.1109/32.935855, doi:10.1109/32.935855.

Ferrario2023

Maria Angela Ferrario and Emily Winter. Applying human values theory to software engineering practice: lessons and implications. IEEE Transactions on Software Engineering, 49(3):973–990, Mar 2023. URL: https://doi.org/10.1109/tse.2022.3170087, doi:10.1109/tse.2022.3170087.

Fischer2015

Lars Fischer and Stefan Hanenberg. An empirical investigation of the effects of type systems and code completion on API usability using TypeScript and JavaScript in MS Visual Studio. In Proc. Symposium on Dynamic Languages (DL). ACM, Oct 2015. URL: https://doi.org/10.1145/2816707.2816720, doi:10.1145/2816707.2816720.

Ford2016

Denae Ford, Justin Smith, Philip J. Guo, and Chris Parnin. Paradise unplugged: identifying barriers for female participation on Stack Overflow. In Proc. International Symposium on the Foundations of Software Engineering (FSE). ACM, Nov 2016. URL: https://doi.org/10.1145/2950290.2950331, doi:10.1145/2950290.2950331.

Ford2017

Denae Ford, Thomas Zimmermann, Christian Bird, and Nachiappan Nagappan. Characterizing software engineering work with personas based on knowledge worker actions. In Proc. International Symposium on Empirical Software Engineering and Measurement (ESEM). IEEE, Nov 2017. URL: https://doi.org/10.1109/esem.2017.54, doi:10.1109/esem.2017.54.

Ford2019

Denae Ford, Mahnaz Behroozi, Alexander Serebrenik, and Chris Parnin. Beyond the code itself: how programmers really look at pull requests. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2019. URL: https://doi.org/10.1109/icse-seis.2019.00014, doi:10.1109/icse-seis.2019.00014.

Freeman1972

Jo Freeman. The tyranny of structurelessness. The Second Wave, 1972.

Fritzsch2021

Jonas Fritzsch, Marvin Wyrich, Justus Bogner, and Stefan Wagner. Résumé-driven development: a definition and empirical characterization. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2021. URL: https://doi.org/10.1109/icse-seis52602.2021.00011, doi:10.1109/icse-seis52602.2021.00011.

Fucci2016

Davide Fucci, Giuseppe Scanniello, Simone Romano, Martin Shepperd, Boyce Sigweni, Fernando Uyaguari, Burak Turhan, Natalia Juristo, and Markku Oivo. An external replication on the effects of test-driven development using a multi-site blind analysis approach. In Proc. International Symposium on Empirical Software Engineering and Measurement (ESEM). ACM, Sep 2016. URL: https://doi.org/10.1145/2961111.2962592, doi:10.1145/2961111.2962592.

Fucci2020

Davide Fucci, Giuseppe Scanniello, Simone Romano, and Natalia Juristo. Need for sleep: the impact of a night of sleep deprivation on novice developers' performance. IEEE Transactions on Software Engineering, 46(1):1–19, Jan 2020. URL: https://doi.org/10.1109/tse.2018.2834900, doi:10.1109/tse.2018.2834900.

Galappaththi2023

Akalanka Galappaththi and Sarah Nadi. A data set of generalizable python code change patterns. 2023. arXiv:2304.04983.

Gallagher2017

Kevin Gallagher, Sameer Patil, and Nasir D. Memon. New me: understanding expert and non-expert perceptions and usage of the tor anonymity network. In Proc. Symposium on Usable Privacy and Security (SOUPS), 385–398. USENIX Association, 2017. URL: https://www.usenix.org/conference/soups2017/technical-sessions/presentation/gallagher.

Gamboa2021

Catarina Gamboa, Paulo Alexandre Santos, Christopher S. Timperley, and Alcides Fonseca. User-driven design and evaluation of liquid types in Java. 2021. arXiv:2110.05444.

Gao2017

Zheng Gao, Christian Bird, and Earl T. Barr. To type or not to type: quantifying detectable bugs in JavaScript. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2017. URL: https://doi.org/10.1109/icse.2017.75, doi:10.1109/icse.2017.75.

Gao2020

Gao Gao, Finn Voichick, Michelle Ichinco, and Caitlin Kelleher. Exploring programmers' API learning processes: collecting web resources as external memory. In Symposium on Visual Languages and Human-Centric Computing (VL/HCC). IEEE, Aug 2020. URL: https://doi.org/10.1109/vl/hcc50065.2020.9127274, doi:10.1109/vl/hcc50065.2020.9127274.

Gauthier2013

Francois Gauthier and Ettore Merlo. Semantic smells and errors in access control models: a case study in PHP. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2013. URL: https://doi.org/10.1109/icse.2013.6606670, doi:10.1109/icse.2013.6606670.

Ghiotto2020

Gleiph Ghiotto, Leonardo Murta, Marcio Barros, and André van der Hoek. On the nature of merge conflicts: a study of 2,731 open source Java projects hosted by GitHub. IEEE Transactions on Software Engineering, 46(8):892–915, Aug 2020. URL: https://doi.org/10.1109/tse.2018.2871083, doi:10.1109/tse.2018.2871083.

Giger2011

Emanuel Giger, Martin Pinzger, and Harald Gall. Using the Gini Coefficient for bug prediction in Eclipse. In Proc. International Workshop on Principles on Software Evolution/Workshop on Software Evolution (IWPSE-EVOL). ACM Press, 2011. URL: https://doi.org/10.1145/2024445.2024455, doi:10.1145/2024445.2024455.

Glanz2020

Leonid Glanz, Patrick Müller, Lars Baumgärtner, Michael Reif, Sven Amann, Pauline Anthonysamy, and Mira Mezini. Hidden in plain sight: obfuscated strings threatening your privacy. In Proc. Asia Conference on Computer and Communications Security (ACCCS). ACM, Oct 2020. URL: https://doi.org/10.1145/3320269.3384745, doi:10.1145/3320269.3384745.

Golubev2021

Yaroslav Golubev, Zarina Kurbatova, Eman Abdullah AlOmar, Timofey Bryksin, and Mohamed Wiem Mkaouer. One thousand and one stories: a large-scale survey of software refactoring. In Proc. European Software Engineering Conference/International Symposium on the Foundations of Software Engineering (ESEC/FSE). ACM, Aug 2021. URL: https://doi.org/10.1145/3468264.3473924, doi:10.1145/3468264.3473924.

Gousios2016

Georgios Gousios, Margaret-Anne Storey, and Alberto Bacchelli. Work practices and challenges in pull-based development. In Proc. International Conference on Software Engineering (ICSE). ACM, May 2016. URL: https://doi.org/10.1145/2884781.2884826, doi:10.1145/2884781.2884826.

Graziotin2014

Daniel Graziotin, Xiaofeng Wang, and Pekka Abrahamsson. Happy software developers solve problems better: psychological measurements in empirical software engineering. PeerJ Computer Science, 2:e289, Mar 2014. URL: https://doi.org/10.7717/peerj.289, doi:10.7717/peerj.289.

Green1996

Thomas R. G. Green and Marian Petre. Usability analysis of visual programming environments: a 'cognitive dimensions' framework. Journal of Visual Languages & Computing, 7(2):131–174, Jun 1996. URL: https://doi.org/10.1006/jvlc.1996.0009, doi:10.1006/jvlc.1996.0009.

Gu2018

Xiaodong Gu, Hongyu Zhang, and Sunghun Kim. Deep code search. In Proc. International Conference on Software Engineering (ICSE). ACM, May 2018. URL: https://doi.org/10.1145/3180155.3180167, doi:10.1145/3180155.3180167.

Guler2019

Emre Güler, Cornelius Aschermann, Ali Abbasi, and Thorsten Holz. AntiFuzz: impeding fuzzing audits of binary executables. In Proc. USENIX Conference on Security Symposium, 1931–1947. Aug 2019. URL: https://www.usenix.org/conference/usenixsecurity19/presentation/guler, doi:10.5555/3361338.3361472.

Gulzar2016

Muhammad Ali Gulzar, Matteo Interlandi, Seunghyun Yoo, Sai Deep Tetali, Tyson Condie, Todd Millstein, and Miryung Kim. BigDebug: debugging primitives for interactive big data processing in Spark. In Proc. International Conference on Software Engineering (ICSE). ACM, May 2016. URL: https://doi.org/10.1145/2884781.2884813, doi:10.1145/2884781.2884813.

Gunatilake2023

Hashini Gunatilake, John Grundy, Ingo Mueller, and Rashina Hoda. Empathy models and software engineering – a preliminary analysis and taxonomy. 2023. arXiv:arXiv:2305.03941.

Han2021

Junxiao Han, Shuiguang Deng, David Lo, Chen Zhi, Jianwei Yin, and Xin Xia. An empirical study of the landscape of open source projects in baidu, alibaba, and tencent. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2021. URL: https://doi.org/10.1109/icse-seip52600.2021.00039, doi:10.1109/icse-seip52600.2021.00039.

Hanenberg2010

Stefan Hanenberg. An experiment about static and dynamic type systems. In Proc. International Conference on Object-Oriented Programming Systems Languages and Applications (OOPSLA). ACM Press, 2010. URL: https://doi.org/10.1145/1869459.1869462, doi:10.1145/1869459.1869462.

Hanenberg2013

Stefan Hanenberg, Sebastian Kleinschmager, Romain Robbes, éric Tanter, and Andreas Stefik. An empirical study on the impact of static typing on software maintainability. Empirical Software Engineering, 19(5):1335–1382, Dec 2013. URL: https://doi.org/10.1007/s10664-013-9289-1, doi:10.1007/s10664-013-9289-1.

Hannay2010

J.E. Hannay, E. Arisholm, H. Engvik, and D.I.K. Sjøberg. Effects of personality on pair programming. IEEE Transactions on Software Engineering, 36(1):61–80, Jan 2010. URL: https://doi.org/10.1109/tse.2009.41, doi:10.1109/tse.2009.41.

Harms2016

Kyle James Harms, Jason Chen, and Caitlin L. Kelleher. Distractors in Parsons Problems decrease learning efficiency for young novice programmers. In Proc. Conference on International Computing Education Research (ICER). ACM, Aug 2016. URL: https://doi.org/10.1145/2960310.2960314, doi:10.1145/2960310.2960314.

Hata2019

Hideaki Hata, Christoph Treude, Raula Gaikovina Kula, and Takashi Ishio. 9.6 million links in source code comments: purpose, evolution, and decay. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2019. URL: https://doi.org/10.1109/icse.2019.00123, doi:10.1109/icse.2019.00123.

Hatton1994

L. Hatton and A. Roberts. How accurate is scientific software? IEEE Transactions on Software Engineering, 20(10):785–797, 1994. URL: https://doi.org/10.1109/32.328993, doi:10.1109/32.328993.

Hatton1997

L. Hatton. The t-experiments: errors in scientific software. In Ronald F. Boisvert, editor, Quality of Numerical Software, pages 12–31. Springer US, 1997. URL: https://doi.org/10.1007/978-1-5041-2940-4_2, doi:10.1007/978-1-5041-2940-4_2.

Hayashi2019

Junichi Hayashi, Yoshiki Higo, Shinsuke Matsumoto, and Shinji Kusumoto. Impacts of daylight saving time on software development. In Proc. International Conference on Mining Software Repositories (MSR). IEEE, May 2019. URL: https://doi.org/10.1109/msr.2019.00076, doi:10.1109/msr.2019.00076.

Hemmati2013

Hadi Hemmati, Sarah Nadi, Olga Baysal, Oleksii Kononenko, Wei Wang, Reid Holmes, and Michael W. Godfrey. The MSR Cookbook: mining a decade of research. In Proc. International Conference on Mining Software Repositories (MSR). IEEE, May 2013. URL: https://doi.org/10.1109/msr.2013.6624048, doi:10.1109/msr.2013.6624048.

Hermans2011

Felienne Hermans, Martin Pinzger, and Arie van Deursen. Supporting professional spreadsheet users by generating leveled dataflow diagrams. In Proc. International Conference on Software Engineering (ICSE). ACM, May 2011. URL: https://doi.org/10.1145/1985793.1985855, doi:10.1145/1985793.1985855.

Hermans2016

Felienne Hermans and Efthimia Aivaloglou. Do code smells hamper novice programming? a controlled experiment on Scratch programs. In Proc. International Conference on Program Comprehension (ICPC). IEEE, May 2016. URL: https://doi.org/10.1109/icpc.2016.7503706, doi:10.1109/icpc.2016.7503706.

Hermans2021

Felienne Hermans. The Programmer's Brain: What Every Programmer Needs to Know About Cognition. Manning, 2021. ISBN 9781617298677.

Herraiz2010

Israel Herraiz and Ahmed E. Hassan. Beyond lines of code: do we need more complexity metrics? In Andy Oram and Greg Wilson, editors, Making Software. O'Reilly, 2010.

Herzig2013

Kim Herzig, Sascha Just, and Andreas Zeller. It's not a bug, it's a feature: how misclassification impacts bug prediction. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2013. URL: https://doi.org/10.1109/icse.2013.6606585, doi:10.1109/icse.2013.6606585.

Hindle2012

Abram Hindle, Christian Bird, Thomas Zimmermann, and Nachiappan Nagappan. Relating requirements to implementation via topic analysis: do topics extracted from requirements make sense to managers and developers? In Proc. International Conference on Software Maintenance (ICSM). IEEE, Sep 2012. URL: https://doi.org/10.1109/icsm.2012.6405278, doi:10.1109/icsm.2012.6405278.

Hindle2016

Abram Hindle, Earl T. Barr, Mark Gabel, Zhendong Su, and Premkumar Devanbu. On the naturalness of software. Communications of the ACM, 59(5):122–131, Apr 2016. URL: https://doi.org/10.1145/2902362, doi:10.1145/2902362.

Hofmeister2017

Johannes Hofmeister, Janet Siegmund, and Daniel V. Holt. Shorter identifier names take longer to comprehend. In Proc. International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, Feb 2017. URL: https://doi.org/10.1109/saner.2017.7884623, doi:10.1109/saner.2017.7884623.

Hora2021a

Andre Hora. Googling for software development: what developers search for and what they find. In Proc. International Conference on Mining Software Repositories (MSR). IEEE, May 2021. URL: https://doi.org/10.1109/msr52588.2021.00044, doi:10.1109/msr52588.2021.00044.

Hora2021b

Andre Hora. What code is deliberately excluded from test coverage and why? In Proc. International Conference on Mining Software Repositories (MSR). IEEE, May 2021. URL: https://doi.org/10.1109/msr52588.2021.00051, doi:10.1109/msr52588.2021.00051.

Hundhausen2011

Christopher D. Hundhausen, Pawan Agarwal, and Michael Trevisan. Online vs. face-to-face pedagogical code reviews. In Proc. Technical Symposium on Computer Science Education (SIGCSE). ACM Press, 2011. URL: https://doi.org/10.1145/1953163.1953201, doi:10.1145/1953163.1953201.

Inozemtseva2014

Laura Inozemtseva and Reid Holmes. Coverage is not strongly correlated with test suite effectiveness. In Proc. International Conference on Software Engineering (ICSE). ACM, May 2014. URL: https://doi.org/10.1145/2568225.2568271, doi:10.1145/2568225.2568271.

Jacobson2013

Ivar Jacobson, Pan-Wei Ng, Paul E. McMahon, Ian Spence, and Svante Lidman. The Essence of Software Engineering: Applying the SEMAT Kernel. Addison-Wesley Professional, 2013. ISBN 9780321885951.

Jesse2022

Kevin Jesse, Premkumar Devanbu, and Anand Ashok Sawant. Learning to predict user-defined types. IEEE Transactions on Software Engineering, pages 1–1, 2022. URL: https://doi.org/10.1109/tse.2022.3178945, doi:10.1109/tse.2022.3178945.

Jiang2022

Yuan Jiang, Christian Kastner, and Shurui Zhou. Elevating Jupyter notebook maintenance tooling by identifying and extracting notebook structures. In 2022 IEEE International Conference on Software Maintenance and Evolution (ICSME). IEEE, Oct 2022. URL: https://doi.org/10.1109/icsme55016.2022.00047, doi:10.1109/icsme55016.2022.00047.

Jin2021

Xianhao Jin and Francisco Servant. What helped, and what did not? an evaluation of the strategies to improve continuous integration. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2021. URL: https://doi.org/10.1109/icse43902.2021.00031, doi:10.1109/icse43902.2021.00031.

Johnson2023

Brittany Johnson, Christian Bird, Denae Ford, Nicole Forsgren, and Tom Zimmermann. Make your tools sparkle with trust: the PICSE framework for trust in software tools. In ICSE SEIP. May 2023. URL: https://www.microsoft.com/en-us/research/publication/the-picse-framework-for-trust-in-software-tools/.

Jolak2020

Rodi Jolak, Maxime Savary-Leblanc, Manuela Dalibor, Andreas Wortmann, Regina Hebig, Juraj Vincur, Ivan Polasek, Xavier Le Pallec, Sébastien Gérard, and Michel R. V. Chaudron. Software engineering whispers: the effect of textual vs. graphical software design descriptions on software design communication. Empirical Software Engineering, 25(6):4427–4471, Sep 2020. URL: https://doi.org/10.1007/s10664-020-09835-6, doi:10.1007/s10664-020-09835-6.

Jorgensen2011

Magne Jørgensen and Stein Grimstad. The impact of irrelevant and misleading information on software development effort estimates: a randomized controlled field experiment. IEEE Transactions on Software Engineering, 37(5):695–707, Sep 2011. URL: https://doi.org/10.1109/tse.2010.78, doi:10.1109/tse.2010.78.

Jorgensen2012

Magne Jørgensen and Stein Grimstad. Software development estimation biases: the role of interdependence. IEEE Transactions on Software Engineering, 38(3):677–693, May 2012. URL: https://doi.org/10.1109/tse.2011.40, doi:10.1109/tse.2011.40.

Jovanovic2022

Ana Jovanovic and Allison Sullivan. Towards automated input generation for sketching alloy models. In Proceedings of the IEEE/ACM 10th International Conference on Formal Methods in Software Engineering. ACM, May 2022. URL: https://doi.org/10.1145/3524482.3527651, doi:10.1145/3524482.3527651.

Kaleeswaran2023

Arut Prakash Kaleeswaran, Arne Nordmann, Thomas Vogel, and Lars Grunske. A user study for evaluation of formal verification results and their explanation at Bosch. 2023. arXiv:2304.08950.

Kamienski2021

Arthur V. Kamienski, Luisa Palechor, Cor-Paul Bezemer, and Abram Hindle. PySStuBs: characterizing single-statement bugs in popular open-source Python projects. In Proc. International Conference on Mining Software Repositories (MSR). IEEE, May 2021. URL: https://doi.org/10.1109/msr52588.2021.00066, doi:10.1109/msr52588.2021.00066.

KanatAlexander2012

Max Kanat-Alexander. Code Simplicity: The Science of Software Development. O'Reilly, 2012. ISBN 9781449313890.

Kapser2008

Cory J. Kapser and Michael W. Godfrey. "cloning considered harmful" considered harmful: patterns of cloning in software. Empirical Software Engineering, 13(6):645–692, Jul 2008. URL: https://doi.org/10.1007/s10664-008-9076-6, doi:10.1007/s10664-008-9076-6.

Kasi2013

Bakhtiar Khan Kasi and Anita Sarma. Cassandra: proactive conflict minimization through optimized task scheduling. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2013. URL: https://doi.org/10.1109/icse.2013.6606619, doi:10.1109/icse.2013.6606619.

Kavaler2019

David Kavaler, Asher Trockman, Bogdan Vasilescu, and Vladimir Filkov. Tool choice matters: JavaScript quality assurance tools and usage outcomes in GitHub projects. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2019. URL: https://doi.org/10.1109/icse.2019.00060, doi:10.1109/icse.2019.00060.

Kernighan1979

Brian W. Kernighan and P. J. Plauger. The Elements of Programming Style. McGraw-Hill, 2nd edition, 1979. ISBN 9780070342071.

Kernighan1981

Brian W. Kernighan and P. J. Plauger. Software Tools in Pascal. Addison-Wesley Professional, 1981. ISBN 9780201103427.

Kernighan1983

Brian W. Kernighan and Rob Pike. The Unix Programming Environment. Prentice-Hall, 1983. ISBN 9780139376818.

Keuning2023

Hieke Keuning, Johan Jeuring, and Bastiaan Heeren. A systematic mapping study of code quality in education – with complete bibliography. 2023. arXiv:2304.13451.

Khomh2012

Foutse Khomh, Tejinder Dhaliwal, Ying Zou, and Bram Adams. Do faster releases improve software quality? an empirical case study of Mozilla Firefox. In Proc. International Conference on Mining Software Repositories (MSR). IEEE, Jun 2012. URL: https://doi.org/10.1109/msr.2012.6224279, doi:10.1109/msr.2012.6224279.

Kiefer2015

Marc Kiefer, Daniel Warzel, and Walter F. Tichy. An empirical study on parallelism in modern open-source projects. In Proc. International Workshop on Software Engineering for Parallel Systems (SEPS). ACM, Oct 2015. URL: https://doi.org/10.1145/2837476.2837481, doi:10.1145/2837476.2837481.

Kim2013a

Dongsun Kim, Jaechang Nam, Jaewoo Song, and Sunghun Kim. Automatic patch generation learned from human-written patches. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2013. URL: https://doi.org/10.1109/icse.2013.6606626, doi:10.1109/icse.2013.6606626.

Kim2013b

Jinhan Kim, Sanghoon Lee, Seung-Won Hwang, and Sunghun Kim. Enriching documents with examples. ACM Transactions on Information Systems, 31(1):1–27, Jan 2013. URL: https://doi.org/10.1145/2414782.2414783, doi:10.1145/2414782.2414783.

Kim2016

Dohyeong Kim, Yonghwi Kwon, Peng Liu, I. Luk Kim, David Mitchel Perry, Xiangyu Zhang, and Gustavo Rodriguez-Rivera. Apex: automatic programming assignment error explanation. In Proc. International Conference on Object-Oriented Programming Systems Languages and Applications (OOPSLA). ACM, Oct 2016. URL: https://doi.org/10.1145/2983990.2984031, doi:10.1145/2983990.2984031.

Kim2023

Jinhan Kim, Jongchan Park, and Shin Yoo. The inversive relationship between bugs and patches: an empirical study. 2023. arXiv:2303.00303.

Kinshumann2011

Kinshuman Kinshumann, Kirk Glerum, Steve Greenberg, Gabriel Aul, Vince Orgovan, Greg Nichols, David Grant, Gretchen Loihle, and Galen Hunt. Debugging in the (very) large: ten years of implementation and experience. Communications of the ACM, 54(7):111–116, Jul 2011. URL: https://doi.org/10.1145/1965724.1965749, doi:10.1145/1965724.1965749.

Kinsman2021

Timothy Kinsman, Mairieli Wessel, Marco A. Gerosa, and Christoph Treude. How do software developers use GitHub actions to automate their workflows? In Proc. International Conference on Mining Software Repositories (MSR). IEEE, May 2021. URL: https://doi.org/10.1109/msr52588.2021.00054, doi:10.1109/msr52588.2021.00054.

Kocaguneli2012

Ekrem Kocaguneli, Tim Menzies, and Jacky W. Keung. On the value of ensemble effort estimation. IEEE Transactions on Software Engineering, 38(6):1403–1416, Nov 2012. URL: https://doi.org/10.1109/tse.2011.111, doi:10.1109/tse.2011.111.

Kochhar2019

Pavneet Singh Kochhar, Eirini Kalliamvakou, Nachiappan Nagappan, Thomas Zimmermann, and Christian Bird. Moving from closed to open source: observations from six transitioned projects to GitHub. IEEE Transactions on Software Engineering, pages 1–1, 2019. URL: https://doi.org/10.1109/tse.2019.2937025, doi:10.1109/tse.2019.2937025.

Kosar2011

Tomaž Kosar, Marjan Mernik, and Jeffrey C. Carver. Program comprehension of domain-specific and general-purpose languages: comparison using a family of experiments. Empirical Software Engineering, 17(3):276–304, Aug 2011. URL: https://doi.org/10.1007/s10664-011-9172-x, doi:10.1007/s10664-011-9172-x.

Kosar2018

Tomaž Kosar, Sašo Gaberc, Jeffrey C. Carver, and Marjan Mernik. Program comprehension of domain-specific and general-purpose languages: replication of a family of experiments using integrated development environments. Empirical Software Engineering, 23(5):2734–2763, Feb 2018. URL: https://doi.org/10.1007/s10664-017-9593-2, doi:10.1007/s10664-017-9593-2.

Krein2016

Jonathan L. Krein, Lutz Prechelt, Natalia Juristo, Aziz Nanthaamornphong, Jeffrey C. Carver, Sira Vegas, Charles D. Knutson, Kevin D. Seppi, and Dennis L. Eggett. A multi-site joint replication of a design patterns experiment using moderator variables to generalize across contexts. IEEE Transactions on Software Engineering, 42(4):302–321, Apr 2016. URL: https://doi.org/10.1109/tse.2015.2488625, doi:10.1109/tse.2015.2488625.

Kula2022a

Elvan Kula, Eric Greuter, Arie van Deursen, and Georgios Gousios. Factors affecting on-time delivery in large-scale agile software development. IEEE Transactions on Software Engineering, 48(9):3573–3592, Sep 2022. URL: https://doi.org/10.1109/tse.2021.3101192, doi:10.1109/tse.2021.3101192.

Kula2022b

Raula Gaikovina Kula and Christoph Treude. In war and peace: the impact of world politics on software ecosystems. 2022. arXiv:2208.01393.

Ladisa2023

Piergiorgio Ladisa, Serena Elisa Ponta, Antonino Sabetta, Matias Martinez, and Olivier Barais. Journey to the center of software supply chain attacks. 2023. arXiv:2304.05200.

Latendresse2021

Jasmine Latendresse, Rabe Abdalkareem, Diego Elias Costa, and Emad Shihab. How effective is continuous integration in indicating single-statement bugs? In Proc. International Conference on Mining Software Repositories (MSR). IEEE, May 2021. URL: https://doi.org/10.1109/msr52588.2021.00062, doi:10.1109/msr52588.2021.00062.

Lee2022

Carol S. Lee, Margaret Bowman, and Jenny L. Wu. Preliminary outcomes from a single-session, asynchronous online, stress and anxiety management workshop for college students. Trends in Psychiatry and Psychotherapy, 2022. URL: https://doi.org/10.47626/2237-6089-2021-0448, doi:10.47626/2237-6089-2021-0448.

Leitao2019

Roxanne Leitão. Technology-facilitated intimate partner abuse: a qualitative analysis of data from online domestic abuse forums. Human–Computer Interaction, 36(3):203–242, Dec 2019. URL: https://doi.org/10.1080/07370024.2019.1685883, doi:10.1080/07370024.2019.1685883.

Leinonen2023

Juho Leinonen, Paul Denny, Stephen MacNeil, Sami Sarsa, Seth Bernstein, Joanne Kim, Andrew Tran, and Arto Hellas. Comparing code explanations created by students and large language models. 2023. arXiv:2304.03938.

Lemire2021

Daniel Lemire. Number parsing at a gigabyte per second. Software: Practice and Experience, 51(8):1700–1727, May 2021. URL: https://doi.org/10.1002/spe.2984, doi:10.1002/spe.2984.

Levy2020

Karen Levy and Bruce Schneier. Privacy threats in intimate relationships. Journal of Cybersecurity, Jan 2020. URL: https://doi.org/10.1093/cybsec/tyaa006, doi:10.1093/cybsec/tyaa006.

Lewis2013

Chris Lewis, Zhongpeng Lin, Caitlin Sadowski, Xiaoyan Zhu, Rong Ou, and E. James Whitehead. Does bug prediction support human developers? findings from a Google case study. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2013. URL: https://doi.org/10.1109/icse.2013.6606583, doi:10.1109/icse.2013.6606583.

Li2013

Sihan Li, Hucheng Zhou, Haoxiang Lin, Tian Xiao, Haibo Lin, Wei Lin, and Tao Xie. A characteristic study on failures of production distributed data-parallel programs. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2013. URL: https://doi.org/10.1109/icse.2013.6606646, doi:10.1109/icse.2013.6606646.

Liao2016

Soohyun Nam Liao, Daniel Zingaro, Michael A. Laurenzano, William G. Griswold, and Leo Porter. Lightweight, early identification of at-risk CS1 students. In Proc. Conference on International Computing Education Research (ICER). ACM, Aug 2016. URL: https://doi.org/10.1145/2960310.2960315, doi:10.1145/2960310.2960315.

Licorish2022

Sherlock A. Licorish and Markus Wagner. Combining GIN and PMD for code improvements. In Proceedings of the Genetic and Evolutionary Computation Conference Companion. ACM, Jul 2022. URL: https://doi.org/10.1145/3520304.3528772, doi:10.1145/3520304.3528772.

Lima2021

Luan P. Lima, Lincoln S. Rocha, Carla I. M. Bezerra, and Matheus Paixao. Assessing exception handling testing practices in open-source libraries. Empirical Software Engineering, Jun 2021. URL: https://doi.org/10.1007/s10664-021-09983-3, doi:10.1007/s10664-021-09983-3.

Lin2020

Sarah Lin, Ibraheem Ali, and Greg Wilson. Ten quick tips for making things findable. PLOS Computational Biology, 16(12):e1008469, Dec 2020. URL: https://doi.org/10.1371/journal.pcbi.1008469, doi:10.1371/journal.pcbi.1008469.

Louis2020

Annie Louis, Santanu Kumar Dash, Earl T. Barr, Michael D. Ernst, and Charles Sutton. Where should i comment my code?: a dataset and model for predicting locations that need comments. In Proc. International Conference on Software Engineering (ICSE). ACM, Jun 2020. URL: https://doi.org/10.1145/3377816.3381736, doi:10.1145/3377816.3381736.

Lo2015

David Lo, Nachiappan Nagappan, and Thomas Zimmermann. How practitioners perceive the relevance of software engineering research. In Proc. International Symposium on the Foundations of Software Engineering (FSE). ACM, Aug 2015. URL: https://doi.org/10.1145/2786805.2786809, doi:10.1145/2786805.2786809.

Lopez2018

Fernando López de la Mora and Sarah Nadi. An empirical study of metric-based comparisons of software libraries. In Proc. International Conference on Predictive Models and Data Analytics in Software Engineering (PROMISE). ACM, Oct 2018. URL: https://doi.org/10.1145/3273934.3273937, doi:10.1145/3273934.3273937.

Maalej2014

Walid Maalej, Rebecca Tiarks, Tobias Roehm, and Rainer Koschke. On the comprehension of program comprehension. ACM Transactions on Software Engineering and Methodology, 23(4):1–37, Sep 2014. URL: https://doi.org/10.1145/2622669, doi:10.1145/2622669.

Madampe2022

Kashumi Madampe, Rashina Hoda, and John Grundy. The emotional roller coaster of responding to requirements changes in software engineering. IEEE Transactions on Software Engineering, pages 1–1, 2022. URL: https://doi.org/10.1109/tse.2022.3172925, doi:10.1109/tse.2022.3172925.

Maenpaa2018

Hanna Mäenpää, Simo Mäkinen, Terhi Kilamo, Tommi Mikkonen, Tomi Männistö, and Paavo Ritala. Organizing for openness: six models for developer involvement in hybrid OSS projects. Journal of Internet Services and Applications, Aug 2018. URL: https://doi.org/10.1186/s13174-018-0088-1, doi:10.1186/s13174-018-0088-1.

Mahmoudi2019

Mehran Mahmoudi, Sarah Nadi, and Nikolaos Tsantalis. Are refactorings to blame? an empirical study of refactorings in merge conflicts. In Proc. International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, Feb 2019. URL: https://doi.org/10.1109/saner.2019.8668012, doi:10.1109/saner.2019.8668012.

Majumder2019

Suvodeep Majumder, Joymallya Chakraborty, Amritanshu Agrawal, and Tim Menzies. Communication and code dependency effects on software code quality: an empirical analysis of herbsleb hypothesis. 2019. arXiv:1904.09954.

Majumder2021

Suvodeep Majumder, Joymallya Chakraborty, Gina R. Bai, Kathryn T. Stolee, and Tim Menzies. Fair enough: searching for sufficient measures of fairness. 2021. arXiv:2110.13029.

Malik2019

Mashkoor Malik, Alexandre C. G. Schimel, Giuseppe Masetti, Marc Roche, Julian Le Deunf, Margaret F.J. Dolan, Jonathan Beaudoin, Jean-Marie Augustin, Travis Hamilton, and Iain Parnum. Results from the first phase of the seafloor backscatter processing software inter-comparison project. Geosciences, 9(12):516, Dec 2019. URL: https://doi.org/10.3390/geosciences9120516, doi:10.3390/geosciences9120516.

Malloy2018

Brian A. Malloy and James F. Power. An empirical analysis of the transition from Python 2 to Python 3. Empirical Software Engineering, 24(2):751–778, Jul 2018. URL: https://doi.org/10.1007/s10664-018-9637-2, doi:10.1007/s10664-018-9637-2.

Mangano2015

Nicolas Mangano, Thomas D. LaToza, Marian Petre, and André van der Hoek. How software designers interact with sketches at the whiteboard. IEEE Transactions on Software Engineering, 41(2):135–156, Feb 2015. URL: https://doi.org/10.1109/tse.2014.2362924, doi:10.1109/tse.2014.2362924.

Margulieux2020

Lauren E. Margulieux, Briana B. Morrison, and Adrienne Decker. Reducing withdrawal and failure rates in introductory programming with subgoal labeled worked examples. International Journal of STEM Education, May 2020. URL: https://doi.org/10.1186/s40594-020-00222-7, doi:10.1186/s40594-020-00222-7.

Marinescu2011

Cristina Marinescu. Are the classes that use exceptions defect prone? In Proc. International Workshop on Principles on Software Evolution/Workshop on Software Evolution (IWPSE-EVOL). ACM Press, 2011. URL: https://doi.org/10.1145/2024445.2024456, doi:10.1145/2024445.2024456.

Masood2020a

Zainab Masood, Rashina Hoda, and Kelly Blincoe. How agile teams make self-assignment work: a grounded theory study. Empirical Software Engineering, 25(6):4962–5005, Sep 2020. URL: https://doi.org/10.1007/s10664-020-09876-x, doi:10.1007/s10664-020-09876-x.

Mattmann2015

Chris A. Mattmann, Joshua Garcia, Ivo Krka, Daniel Popescu, and Nenad Medvidović. Revisiting the anatomy and physiology of the grid. Journal of Grid Computing, 13(1):19–34, Jan 2015. URL: https://doi.org/10.1007/s10723-015-9324-0, doi:10.1007/s10723-015-9324-0.

McGee2011

Sharon McGee and Des Greer. Software requirements change taxonomy: evaluation by case study. In Proc. International Requirements Engineering Conference (RE). IEEE, Aug 2011. URL: https://doi.org/10.1109/re.2011.6051641, doi:10.1109/re.2011.6051641.

McIntosh2011

Shane McIntosh, Bram Adams, Thanh H.D. Nguyen, Yasutaka Kamei, and Ahmed E. Hassan. An empirical study of build maintenance effort. In Proc. International Conference on Software Engineering (ICSE). ACM, May 2011. URL: https://doi.org/10.1145/1985793.1985813, doi:10.1145/1985793.1985813.

McIntosh2021

Lukas McIntosh and Caroline D. Hardin. Do hackathon projects change the world? an empirical analysis of GitHub repositories. In Proc. Technical Symposium on Computer Science Education (SIGCSE). ACM, Mar 2021. URL: https://doi.org/10.1145/3408877.3432435, doi:10.1145/3408877.3432435.

McLeod2011

Laurie McLeod and Stephen G. MacDonell. Factors that affect software systems development project outcomes. ACM Computing Surveys, 43(4):1–56, Oct 2011. URL: https://doi.org/10.1145/1978802.1978803, doi:10.1145/1978802.1978803.

McNamara2018

Andrew McNamara, Justin Smith, and Emerson Murphy-Hill. Does ACM's code of ethics change ethical decision making in software development? In Proc. European Software Engineering Conference/International Symposium on the Foundations of Software Engineering (ESEC/FSE). ACM, Oct 2018. URL: https://doi.org/10.1145/3236024.3264833, doi:10.1145/3236024.3264833.

Mehrpour2022

Sahar Mehrpour and Thomas D. LaToza. Can static analysis tools find more defects? Empirical Software Engineering, Nov 2022. URL: https://doi.org/10.1007/s10664-022-10232-4, doi:10.1007/s10664-022-10232-4.

Meldrum2020

Sarah Meldrum, Sherlock A. Licorish, Caitlin A. Owen, and Bastin Tony Roy Savarimuthu. Understanding Stack Overflow code quality: a recommendation of caution. Science of Computer Programming, 199:102516, Nov 2020. URL: https://doi.org/10.1016/j.scico.2020.102516, doi:10.1016/j.scico.2020.102516.

Meneely2011

Andrew Meneely, Pete Rotella, and Laurie Williams. Does adding manpower also affect quality? an empirical, longitudinal analysis. In Proc. International Symposium on Foundations of Software Engineering/International Symposium on the Foundations of Software Engineering (SIGSOFT/FSE). ACM Press, 2011. URL: https://doi.org/10.1145/2025113.2025128, doi:10.1145/2025113.2025128.

Meng2013

Na Meng, Miryung Kim, and Kathryn S. McKinley. Lase: locating and applying systematic edits by learning from examples. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2013. URL: https://doi.org/10.1109/icse.2013.6606596, doi:10.1109/icse.2013.6606596.

Menzies2016

Tim Menzies, William Nichols, Forrest Shull, and Lucas Layman. Are delayed issues harder to resolve? revisiting cost-to-fix of defects throughout the lifecycle. Empirical Software Engineering, 22(4):1903–1935, Nov 2016. URL: https://doi.org/10.1007/s10664-016-9469-x, doi:10.1007/s10664-016-9469-x.

Meyer2014

André N. Meyer, Thomas Fritz, Gail C. Murphy, and Thomas Zimmermann. Software developers' perceptions of productivity. In Proc. International Symposium on the Foundations of Software Engineering (FSE). ACM, Nov 2014. URL: https://doi.org/10.1145/2635868.2635892, doi:10.1145/2635868.2635892.

Meyer2021

Andre N. Meyer, Earl T. Barr, Christian Bird, and Thomas Zimmermann. Today was a good day: the daily life of software developers. IEEE Transactions on Software Engineering, 47(5):863–880, May 2021. URL: https://doi.org/10.1109/tse.2019.2904957, doi:10.1109/tse.2019.2904957.

Miedema2021

Daphne Miedema, Efthimia Aivaloglou, and George Fletcher. Identifying SQL misconceptions of novices: findings from a think-aloud study. In Proc. Conference on International Computing Education Research (ICER). ACM, Aug 2021. URL: https://doi.org/10.1145/3446871.3469759, doi:10.1145/3446871.3469759.

Miedema2022

Daphne Miedema, George Fletcher, and Efthimia Aivaloglou. So many brackets!: an analysis of how SQL learners (mis)manage complexity during query formulation. In Proc. International Conference on Program Comprehension (ICPC). ACM, May 2022. doi:10.1145/3524610.3529158.

Miller2016

Craig S. Miller and Amber Settle. Some trouble with transparency: an analysis of student errors with object-oriented Python. In Proc. Conference on International Computing Education Research (ICER). ACM, Aug 2016. URL: https://doi.org/10.1145/2960310.2960327, doi:10.1145/2960310.2960327.

Miller2020

Barton Miller, Mengxiao Zhang, and Elisa Heymann. The relevance of classic fuzz testing: have we solved this one? IEEE Transactions on Software Engineering, pages 1–1, 2020. URL: https://doi.org/10.1109/tse.2020.3047766, doi:10.1109/tse.2020.3047766.

Mirzamomen2023

Zahra Mirzamomen and Marcel Böhme. Finding bug-inducing program environments. 2023. arXiv:2304.10044.

Mitropoulos2019

Dimitris Mitropoulos, Panos Louridas, Vitalis Salis, and Diomidis Spinellis. Time present and time past: analyzing the evolution of JavaScript code in the wild. In Proc. International Conference on Mining Software Repositories (MSR). IEEE, May 2019. URL: https://doi.org/10.1109/msr.2019.00029, doi:10.1109/msr.2019.00029.

Mo2021

Ran Mo, Yuanfang Cai, Rick Kazman, Lu Xiao, and Qiong Feng. Architecture anti-patterns: automatically detectable violations of design principles. IEEE Transactions on Software Engineering, 47(5):1008–1028, May 2021. URL: https://doi.org/10.1109/tse.2019.2910856, doi:10.1109/tse.2019.2910856.

Mockus2010

Audris Mockus. Organizational volatility and its effects on software defects. In Proc. International Symposium on the Foundations of Software Engineering (FSE). ACM Press, 2010. URL: https://doi.org/10.1145/1882291.1882311, doi:10.1145/1882291.1882311.

Moe2010

Nils Brede Moe, Torgeir Dingsøyr, and Tore Dybå. A teamwork model for understanding an agile team: a case study of a Scrum project. Information and Software Technology, 52(5):480–491, May 2010. URL: https://doi.org/10.1016/j.infsof.2009.11.004, doi:10.1016/j.infsof.2009.11.004.

Mokhov2018

Andrey Mokhov, Neil Mitchell, and Simon Peyton Jones. Build systems à la carte. Proceedings of the ACM on Programming Languages, 2(ICFP):1–29, Jul 2018. URL: https://doi.org/10.1145/3236774, doi:10.1145/3236774.

Moldon2021

Lukas Moldon, Markus Strohmaier, and Johannes Wachs. How gamification affects software developers: cautionary evidence from a natural experiment on GitHub. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2021. URL: https://doi.org/10.1109/icse43902.2021.00058, doi:10.1109/icse43902.2021.00058.

Muhammad2019

Hisham Muhammad, Lucas C. Villa Real, and Michael Homer. Taxonomy of package management in programming languages and operating systems. In Proc. Workshop on Programming Languages and Operating Systems (PLOS). ACM, Oct 2019. URL: https://doi.org/10.1145/3365137.3365402, doi:10.1145/3365137.3365402.

Nagappan2008

Nachiappan Nagappan, E. Michael Maximilien, Thirumalesh Bhat, and Laurie Williams. Realizing quality improvement through test driven development: results and experiences of four industrial teams. Empirical Software Engineering, 13(3):289–302, Feb 2008. URL: https://doi.org/10.1007/s10664-008-9062-z, doi:10.1007/s10664-008-9062-z.

Nagappan2015

Meiyappan Nagappan, Romain Robbes, Yasutaka Kamei, éric Tanter, Shane McIntosh, Audris Mockus, and Ahmed E. Hassan. An empirical study of goto in C code from GitHub repositories. In Proc. International Symposium on the Foundations of Software Engineering (FSE). ACM, Aug 2015. URL: https://doi.org/10.1145/2786805.2786834, doi:10.1145/2786805.2786834.

Nakajo1991

Takeshi Nakajo and Hitoshi Kume. A case history analysis of software error cause-effect relationships. IEEE Transactions on Software Engineering, 17(8):830–838, 1991. URL: https://doi.org/10.1109/32.83917, doi:10.1109/32.83917.

Nakshatri2016

Suman Nakshatri, Maithri Hegde, and Sahithi Thandra. Analysis of exception handling patterns in Java projects. In Proc. International Conference on Mining Software Repositories (MSR). ACM, May 2016. URL: https://doi.org/10.1145/2901739.2903499, doi:10.1145/2901739.2903499.

Nassif2021

Mathieu Nassif, Alexa Hernandez, Ashvitha Sridharan, and Martin P. Robillard. Generating unit tests for documentation. IEEE Transactions on Software Engineering, 2021. URL: https://doi.org/10.1109/tse.2021.3087087, doi:10.1109/tse.2021.3087087.

Ndukwe2023

Ifeanyi G. Ndukwe, Sherlock A. Licorish, Amjed Tahir, and Stephen G. MacDonell. How have views on software quality differed over time? research and practice viewpoints. Journal of Systems and Software, 195:111524, Jan 2023. URL: https://doi.org/10.1016/j.jss.2022.111524, doi:10.1016/j.jss.2022.111524.

Near2016

Joseph P. Near and Daniel Jackson. Finding security bugs in web applications using a catalog of access control patterns. In Proc. International Conference on Software Engineering (ICSE). ACM, May 2016. URL: https://doi.org/10.1145/2884781.2884836, doi:10.1145/2884781.2884836.

Nejati2023

Mahtab Nejati, Mahmoud Alfadel, and Shane McIntosh. Code review of build system specifications: prevalence, purposes, patterns, and perceptions. In Proc. ICSE'23. 2023. URL: https://rebels.cs.uwaterloo.ca/confpaper/2023/05/13/code-review-of-build-system-specifications-prevalence-purposes-patterns-and-perceptions.html.

Newman2023

Kaia Newman, Madeline Endres, Brittany Johnson, and Westley Weimer. From organizations to individuals: psychoactive substance use by professional programmers. 2023. arXiv:2305.01056.

Ni2021

Ansong Ni, Daniel Ramos, Aidan Z. H. Yang, Ines Lynce, Vasco Manquinho, Ruben Martins, and Claire Le Goues. SOAR: a synthesis approach for data science API refactoring. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2021. URL: https://doi.org/10.1109/icse43902.2021.00023, doi:10.1109/icse43902.2021.00023.

Nielebock2018

Sebastian Nielebock, Dariusz Krolikowski, Jacob Krüger, Thomas Leich, and Frank Ortmeier. Commenting source code: is it worth it for small programming tasks? Empirical Software Engineering, 24(3):1418–1457, Nov 2018. URL: https://doi.org/10.1007/s10664-018-9664-z, doi:10.1007/s10664-018-9664-z.

Nussli2012

Marc-Antoine Nüssli and Patrick Jermann. Effects of sharing text selections on gaze cross-recurrence and interaction quality in a pair programming task. In Proc. Conference on Computer Supported Cooperative Work (CSCW). ACM Press, 2012. URL: https://doi.org/10.1145/2145204.2145371, doi:10.1145/2145204.2145371.

Oliveira2020

Edson Oliveira, Eduardo Fernandes, Igor Steinmacher, Marco Cristo, Tayana Conte, and Alessandro Garcia. Code and commit metrics of developer productivity: a study on team leaders perceptions. Empirical Software Engineering, 25(4):2519–2549, Apr 2020. URL: https://doi.org/10.1007/s10664-020-09820-z, doi:10.1007/s10664-020-09820-z.

Olson2023

Lauren Olson, Emitzá Guzmán, and Florian Kunneman. Along the margins: marginalized communities' ethical concerns about social platforms. 2023. arXiv:2304.08882.

Overney2020

Cassandra Overney, Jens Meinicke, Christian Kästner, and Bogdan Vasilescu. How to not get rich: an empirical study of donations in open source. In Proc. International Conference on Software Engineering (ICSE). ACM, Jun 2020. URL: https://doi.org/10.1145/3377811.3380410, doi:10.1145/3377811.3380410.

Pan2008

Kai Pan, Sunghun Kim, and E. James Whitehead. Toward an understanding of bug fix patterns. Empirical Software Engineering, 14(3):286–315, Aug 2008. URL: https://doi.org/10.1007/s10664-008-9077-5, doi:10.1007/s10664-008-9077-5.

Pankratius2012

Victor Pankratius, Felix Schmidt, and Gilda Garreton. Combining functional and imperative programming for multicore software: an empirical study evaluating Scala and Java. In Proc. International Conference on Software Engineering (ICSE). IEEE, Jun 2012. URL: https://doi.org/10.1109/icse.2012.6227200, doi:10.1109/icse.2012.6227200.

Paradis2023

Carlos Paradis and Rick Kazman. Building the MSR tool Kaiaulu: design principles and experiences. 2023. arXiv:2304.14570, doi:10.1007/978-3-031-15116-3_6.

Pardos2023

Zachary A. Pardos, Matthew Tang, Ioannis Anastasopoulos, Shreya K. Sheel, and Ethan Zhang. OATutor: an open-source adaptive tutoring system and curated content library for learning sciences research. In Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems. ACM, Apr 2023. URL: https://doi.org/10.1145/3544548.3581574, doi:10.1145/3544548.3581574.

Parnin2012

Chris Parnin and Spencer Rugaber. Programmer information needs after memory failure. In Proc. International Conference on Program Comprehension (ICPC). IEEE, Jun 2012. URL: https://doi.org/10.1109/icpc.2012.6240479, doi:10.1109/icpc.2012.6240479.

Patitsas2016

Elizabeth Patitsas, Jesse Berlin, Michelle Craig, and Steve Easterbrook. Evidence that computer science grades are not bimodal. In Proc. Conference on International Computing Education Research (ICER). ACM, Aug 2016. URL: https://doi.org/10.1145/2960310.2960312, doi:10.1145/2960310.2960312.

Peng2021

Yun Peng, Yu Zhang, and Mingzhe Hu. An empirical study for common language features used in Python projects. In Proc. International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, Mar 2021. URL: https://doi.org/10.1109/saner50967.2021.00012, doi:10.1109/saner50967.2021.00012.

PerezDeRosso2013

Santiago Perez De Rosso and Daniel Jackson. What's wrong with Git? In Proc. Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software (ONWARD). ACM Press, 2013. URL: https://doi.org/10.1145/2509578.2509584, doi:10.1145/2509578.2509584.

PerezDeRosso2016

Santiago Perez De Rosso and Daniel Jackson. Purposes, concepts, misfits, and a redesign of Git. In Proc. International Conference on Object-Oriented Programming Systems Languages and Applications (OOPSLA). ACM, Oct 2016. URL: https://doi.org/10.1145/2983990.2984018, doi:10.1145/2983990.2984018.

Petre2013

Marian Petre. UML in practice. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2013. URL: https://doi.org/10.1109/icse.2013.6606618, doi:10.1109/icse.2013.6606618.

Philip2012

Kavita Philip, Medha Umarji, Megha Agarwala, Susan Elliott Sim, Rosalva Gallardo-Valencia, Cristina V. Lopes, and Sukanya Ratanotayanon. Software reuse through methodical component reuse and amethodical snippet remixing. In Proc. Conference on Computer Supported Cooperative Work (CSCW). ACM Press, 2012. URL: https://doi.org/10.1145/2145204.2145407, doi:10.1145/2145204.2145407.

Piantadosi2020

Valentina Piantadosi, Fabiana Fierro, Simone Scalabrino, Alexander Serebrenik, and Rocco Oliveto. How does code readability change during software evolution? Empirical Software Engineering, 25(6):5374–5412, Sep 2020. URL: https://doi.org/10.1007/s10664-020-09886-9, doi:10.1007/s10664-020-09886-9.

Pietri2019

Antoine Pietri, Diomidis Spinellis, and Stefano Zacchiroli. The software heritage graph dataset: public software development under one roof. In Proc. International Conference on Mining Software Repositories (MSR). IEEE, May 2019. URL: https://doi.org/10.1109/msr.2019.00030, doi:10.1109/msr.2019.00030.

Pohn2023

Daniela Pöhn and Wolfgang Hommel. IMC: a classification of identity management approaches. 2023. arXiv:2301.00444.

Pool2023

Jonathan Robert Pool. Accessibility metatesting: comparing nine testing tools. 2023. arXiv:2304.07591, doi:10.1145/3587281.3587282.

Porter2013

Leo Porter, Cynthia Bailey Lee, and Beth Simon. Halving fail rates using peer instruction. In Proc. Technical Symposium on Computer Science Education (SIGCSE). ACM Press, 2013. URL: https://doi.org/10.1145/2445196.2445250, doi:10.1145/2445196.2445250.

Posnett2011

Daryl Posnett, Abram Hindle, and Premkumar Devanbu. Got issues? do new features and code improvements affect defects? In Proc. Working Conference on Reverse Engineering (WCRE). IEEE, Oct 2011. URL: https://doi.org/10.1109/wcre.2011.33, doi:10.1109/wcre.2011.33.

Prabhu2011

Prakash Prabhu, Yun Zhang, Soumyadeep Ghosh, David I. August, Jialu Huang, Stephen Beard, Hanjun Kim, Taewook Oh, Thomas B. Jablin, Nick P. Johnson, Matthew Zoufaly, Arun Raman, Feng Liu, and David Walker. A survey of the practice of computational science. In Proc. Supercomputing. ACM Press, 2011. URL: https://doi.org/10.1145/2063348.2063374, doi:10.1145/2063348.2063374.

Prana2018

Gede Artha Azriadi Prana, Christoph Treude, Ferdian Thung, Thushari Atapattu, and David Lo. Categorizing the content of GitHub README files. Empirical Software Engineering, 24(3):1296–1327, Oct 2018. URL: https://doi.org/10.1007/s10664-018-9660-3, doi:10.1007/s10664-018-9660-3.

Pritchard2015

David Pritchard. Frequency distribution of error messages. In Proc. Workshop on Evaluation and Usability of Programming Languages and Tools (PLATEAU). ACM, Oct 2015. URL: https://doi.org/10.1145/2846680.2846681, doi:10.1145/2846680.2846681.

Racheva2010

Zornitza Racheva, Maya Daneva, Klaas Sikkel, Andrea Herrmann, and Roel Wieringa. Do we know enough about requirements prioritization in agile projects: insights from a case study. In Proc. International Requirements Engineering Conference (RE). IEEE, Sep 2010. URL: https://doi.org/10.1109/re.2010.27, doi:10.1109/re.2010.27.

Ragkhitwetsagul2021

Chaiyong Ragkhitwetsagul, Jens Krinke, Matheus Paixao, Giuseppe Bianco, and Rocco Oliveto. Toxic code snippets on Stack Overflow. IEEE Transactions on Software Engineering, 47(3):560–581, Mar 2021. URL: https://doi.org/10.1109/tse.2019.2900307, doi:10.1109/tse.2019.2900307.

Rahman2011

Foyzur Rahman and Premkumar Devanbu. Ownership, experience and defects: a fine-grained study of authorship. In Proc. International Conference on Software Engineering (ICSE). ACM, May 2011. URL: https://doi.org/10.1145/1985793.1985860, doi:10.1145/1985793.1985860.

Rahman2013

Foyzur Rahman and Premkumar Devanbu. How, and why, process metrics are better. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2013. URL: https://doi.org/10.1109/icse.2013.6606589, doi:10.1109/icse.2013.6606589.

Rahman2019

Akond Rahman, Chris Parnin, and Laurie Williams. The seven sins: security smells in infrastructure as code scripts. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2019. URL: https://doi.org/10.1109/icse.2019.00033, doi:10.1109/icse.2019.00033.

Rahman2020a

Akond Rahman, Effat Farhana, Chris Parnin, and Laurie Williams. Gang of eight: a defect taxonomy for infrastructure as code scripts. In Proc. International Conference on Software Engineering (ICSE). ACM, Jun 2020. URL: https://doi.org/10.1145/3377811.3380409, doi:10.1145/3377811.3380409.

RakAmnouykit2020

Ingkarat Rak-amnouykit, Daniel McCrevan, Ana Milanova, Martin Hirzel, and Julian Dolby. Python 3 types in the wild: a tale of two type systems. In Proc. International Symposium on Dynamic Languages (ISDL). ACM, Nov 2020. URL: https://doi.org/10.1145/3426422.3426981, doi:10.1145/3426422.3426981.

Reichelt2023

David Georg Reichelt, Stefan Kühne, and Wilhelm Hasselbring. Towards solving the challenge of minimal overhead monitoring. 2023. arXiv:2304.05688, doi:10.1145/3578245.3584851.

2101.00756

Brittany Reid, Marcelo d'Amorim, Markus Wagner, and Christoph Treude. NCQ: code reuse support for node.js developers. 2021. arXiv:2101.00756.

Reimann2023

Lars Reimann and Günter Kniesel-Wünsche. An alternative to cells for selective execution of data science pipelines. 2023. arXiv:2302.14556.

Riccomini2021

Chris Riccomini and Dmitriy Ryaboy. The Missing README: A Guide for the New Software Engineer. No Starch Press, 2021. ISBN 978-1718501836.

Rigby2011

Peter C. Rigby and Margaret-Anne Storey. Understanding broadcast based peer review on open source software projects. In Proc. International Conference on Software Engineering (ICSE). ACM, May 2011. URL: https://doi.org/10.1145/1985793.1985867, doi:10.1145/1985793.1985867.

Rigby2016

Peter C. Rigby, Yue Cai Zhu, Samuel M. Donadelli, and Audris Mockus. Quantifying and mitigating turnover-induced knowledge loss. In Proc. International Conference on Software Engineering (ICSE). ACM, May 2016. URL: https://doi.org/10.1145/2884781.2884851, doi:10.1145/2884781.2884851.

Rigger2020

Manuel Rigger and Zhendong Su. Finding bugs in database systems via query partitioning. Proceedings of the ACM on Programming Languages, Nov 2020. URL: https://doi.org/10.1145/3428279, doi:10.1145/3428279.

Rivers2016

Kelly Rivers, Erik Harpstead, and Ken Koedinger. Learning curve analysis for programming. In Proc. Conference on International Computing Education Research (ICER). ACM, Aug 2016. URL: https://doi.org/10.1145/2960310.2960333, doi:10.1145/2960310.2960333.

Robillard2010

Martin P. Robillard and Rob DeLine. A field study of API learning obstacles. Empirical Software Engineering, 16(6):703–732, Dec 2010. URL: https://doi.org/10.1007/s10664-010-9150-8, doi:10.1007/s10664-010-9150-8.

Rodeghero2021

Paige Rodeghero, Thomas Zimmermann, Brian Houck, and Denae Ford. Please turn your cameras on: remote onboarding of software developers during a pandemic. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2021. URL: https://doi.org/10.1109/icse-seip52600.2021.00013, doi:10.1109/icse-seip52600.2021.00013.

RodriguezPerez2018

Gema Rodríguez-Pérez, Gregorio Robles, and Jesús M. González-Barahona. Reproducibility and credibility in empirical software engineering: a case study based on a systematic literature review of the use of the SZZ algorithm. Information and Software Technology, 99:164–176, Jul 2018. URL: https://doi.org/10.1016/j.infsof.2018.03.009, doi:10.1016/j.infsof.2018.03.009.

Rossbach2010

Christopher J. Rossbach, Owen S. Hofmann, and Emmett Witchel. Is transactional programming actually easier? ACM SIGPLAN Notices, 45(5):47–56, May 2010. URL: https://doi.org/10.1145/1837853.1693462, doi:10.1145/1837853.1693462.

Runge2023

Tobias Runge, Tabea Bordis, Alex Potanin, Thomas Thüm, and Ina Schaefer. Flexible correct-by-construction programming. 2022. arXiv:2211.15261.

Sadowski2019

Caitlin Sadowski and Thomas Zimmermann, editors. Rethinking Productivity in Software Engineering. Apress, 2019. ISBN 9781484242209. URL: https://link.springer.com/book/10.1007\%2F978-1-4842-4221-6.

Sajadi2023

Amirali Sajadi, Kostadin Damevski, and Preetha Chatterjee. Interpersonal Trust in OSS: Exploring Dimensions of Trust in GitHub Pull Requests. In Proceedings of the 45th International Conference on Software Engineering (NIER Track), ICSE '23. 2023. URL: https://preethac.github.io/files/ICSE_NIER_2023.pdf.

Salerno2023

Larissa Salerno, Simone de França Tonhão, Igor Steinmacher, and Christoph Treude. Barriers and self-efficacy: a large-scale study on the impact of OSS courses on student perceptions. 2023. arXiv:2304.14628.

SanchezRuiz2023

José Manuel Sánchez Ruiz, Francisco José Domínguez Mayo, Xavier Oriol, José Francisco Crespo, David Benavides, and Ernest Teniente. A benchmarking proposal for devops practices on open source software projects. 2023. arXiv:2304.14790.

Scalabrino2018

Simone Scalabrino, Mario Linares-Vásquez, Rocco Oliveto, and Denys Poshyvanyk. A comprehensive model for code readability. Journal of Software: Evolution and Process, 30(6):e1958, Jun 2018. URL: https://doi.org/10.1002/smr.1958, doi:10.1002/smr.1958.

Scalabrino2021

Simone Scalabrino, Gabriele Bavota, Christopher Vendome, Mario Linares-Vasquez, Denys Poshyvanyk, and Rocco Oliveto. Automatically assessing code understandability. IEEE Transactions on Software Engineering, 47(3):595–613, Mar 2021. URL: https://doi.org/10.1109/tse.2019.2901468, doi:10.1109/tse.2019.2901468.

Scanniello2017

Giuseppe Scanniello, Michele Risi, Porfirio Tramontana, and Simone Romano. Fixing faults in C and Java source code. ACM Transactions on Software Engineering and Methodology, 26(2):1–43, Oct 2017. URL: https://doi.org/10.1145/3104029, doi:10.1145/3104029.

Scarsbrook2023

Joshua D. Scarsbrook, Mark Utting, and Ryan K. L. Ko. Typescript's evolution: an analysis of feature adoption over time. 2023. arXiv:2303.09802.

Schweinsberg2021

Martin Schweinsberg and others. Same data, different conclusions: radical dispersion in empirical results when independent analysts operationalize and test the same hypothesis. Organizational Behavior and Human Decision Processes, 165:228–249, Jul 2021. URL: https://doi.org/10.1016/j.obhdp.2021.02.003, doi:10.1016/j.obhdp.2021.02.003.

Sedano2017

Todd Sedano, Paul Ralph, and Cecile Peraire. Software development waste. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2017. URL: https://doi.org/10.1109/icse.2017.20, doi:10.1109/icse.2017.20.

Sellitto2022

Giulia Sellitto, Emanuele Iannone, Zadia Codabux, Valentina Lenarduzzi, Andrea De Lucia, Fabio Palomba, and Filomena Ferrucci. Toward understanding the impact of refactoring on program comprehension. In 2022 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, Mar 2022. URL: https://doi.org/10.1109/saner53432.2022.00090, doi:10.1109/saner53432.2022.00090.

Shao2020

Shudi Shao, Zhengyi Qiu, Xiao Yu, Wei Yang, Guoliang Jin, Tao Xie, and Xintao Wu. Database-access performance antipatterns in database-backed web applications. In Proc. International Conference on Software Maintenance and Evolution (ICSME). IEEE, Sep 2020. URL: https://doi.org/10.1109/icsme46990.2020.00016, doi:10.1109/icsme46990.2020.00016.

Sharma2021

Pankajeshwara Nand Sharma, Bastin Tony Roy Savarimuthu, and Nigel Stanger. Extracting rationale for open source software development decisions—a study of python email archives. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2021. URL: https://doi.org/10.1109/icse43902.2021.00095, doi:10.1109/icse43902.2021.00095.

Sharp2016

Helen Sharp, Yvonne Dittrich, and Cleidson R. B. de Souza. The role of ethnographic studies in empirical software engineering. IEEE Transactions on Software Engineering, 42(8):786–804, Aug 2016. URL: https://doi.org/10.1109/tse.2016.2519887, doi:10.1109/tse.2016.2519887.

Sholler2019

Dan Sholler, Igor Steinmacher, Denae Ford, Mara Averick, Mike Hoye, and Greg Wilson. Ten simple rules for helping newcomers become contributors to open projects. PLOS Computational Biology, 15(9):e1007296, Sep 2019. URL: https://doi.org/10.1371/journal.pcbi.1007296, doi:10.1371/journal.pcbi.1007296.

Sliwerski2005

Jacek Śliwerski, Thomas Zimmermann, and Andreas Zeller. When do changes induce fixes? In Proc. International Conference on Mining Software Repositories (MSR). ACM Press, 2005. URL: https://doi.org/10.1145/1083142.1083147, doi:10.1145/1083142.1083147.

Soremekun2021

Ezekiel Soremekun, Lukas Kirschner, Marcel Böhme, and Andreas Zeller. Locating faults with program slicing: an empirical analysis. Empirical Software Engineering, Apr 2021. URL: https://doi.org/10.1007/s10664-020-09931-7, doi:10.1007/s10664-020-09931-7.

Spinellis2016

Diomidis Spinellis, Panos Louridas, and Maria Kechagia. The evolution of c programming practices. In Proc. International Conference on Software Engineering (ICSE). ACM, May 2016. URL: https://doi.org/10.1145/2884781.2884799, doi:10.1145/2884781.2884799.

Spinellis2021

Diomidis Spinellis and Paris Avgeriou. Evolution of the unix system architecture: an exploratory case study. IEEE Transactions on Software Engineering, 47(6):1134–1163, Jun 2021. URL: https://doi.org/10.1109/tse.2019.2892149, doi:10.1109/tse.2019.2892149.

Staples2013

Mark Staples, Rafal Kolanski, Gerwin Klein, Corey Lewis, June Andronick, Toby Murray, Ross Jeffery, and Len Bass. Formal specifications better than function points for code sizing. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2013. URL: https://doi.org/10.1109/icse.2013.6606692, doi:10.1109/icse.2013.6606692.

Stefik2011

Andreas Stefik, Susanna Siebert, Melissa Stefik, and Kim Slattery. An empirical comparison of the accuracy rates of novices using the Quorum, Perl, and Randomo programming languages. In Proc. Workshop on Evaluation and Usability of Programming Languages and Tools (PLATEAU). ACM Press, 2011. URL: https://doi.org/10.1145/2089155.2089159, doi:10.1145/2089155.2089159.

Stefik2013

Andreas Stefik and Susanna Siebert. An empirical investigation into programming language syntax. ACM Transactions on Computing Education, 13(4):1–40, Nov 2013. URL: https://doi.org/10.1145/2534973, doi:10.1145/2534973.

Stolee2011

Kathryn T. Stolee and Sebastian Elbaum. Refactoring pipe-like mashups for end-user programmers. In Proc. International Conference on Software Engineering (ICSE). ACM, May 2011. URL: https://doi.org/10.1145/1985793.1985805, doi:10.1145/1985793.1985805.

Stylos2007

Jeffrey Stylos and Steven Clarke. Usability implications of requiring parameters in objects' constructors. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2007. URL: https://doi.org/10.1109/icse.2007.92, doi:10.1109/icse.2007.92.

Sven2019

Amann Sven, Hoan Anh Nguyen, Sarah Nadi, Tien N. Nguyen, and Mira Mezini. Investigating next steps in static API-misuse detection. In Proc. International Conference on Mining Software Repositories (MSR). IEEE, May 2019. URL: https://doi.org/10.1109/msr.2019.00053, doi:10.1109/msr.2019.00053.

Swillus2023

Mark Swillus and Andy Zaidman. Deconstructing sentimental Stack Overflow posts through interviews: exploring the case of software testing. CHASE 2023 Registered Reports, 2023. arXiv:2304.11280.

Taipalus2018

Toni Taipalus, Mikko Siponen, and Tero Vartiainen. Errors and complications in SQL query formulation. ACM Transactions on Computing Education, 18(3):1–29, Sep 2018. URL: https://doi.org/10.1145/3231712, doi:10.1145/3231712.

Taipalus2021

Toni Taipalus, Hilkka Grahn, and Hadi Ghanbari. Error messages in relational database management systems: a comparison of effectiveness, usefulness, and user confidence. Journal of Systems and Software, 181:111034, Nov 2021. URL: https://doi.org/10.1016/j.jss.2021.111034, doi:10.1016/j.jss.2021.111034.

Tamburri2020

Damian Andrew Tamburri, Kelly Blincoe, Fabio Palomba, and Rick Kazman. "the canary in the coal mine…" a cautionary tale from the decline of SourceForge. Software: Practice and Experience, 50(10):1930–1951, Jul 2020. URL: https://doi.org/10.1002/spe.2874, doi:10.1002/spe.2874.

Tan2023

Xin Tan, Yiran Chen, Haohua Wu, Minghui Zhou, and Li Zhang. Is it enough to recommend tasks to newcomers? Understanding mentoring on good first issues. ICSE 2023, 2023. arXiv:2302.05058.

Tang2021

Henry Tang and Sarah Nadi. On using stack overflow comment-edit pairs to recommend code maintenance changes. Empirical Software Engineering, May 2021. URL: https://doi.org/10.1007/s10664-021-09954-8, doi:10.1007/s10664-021-09954-8.

Tao2021

Yida Tao, Zhihui Chen, Yepang Liu, Jifeng Xuan, Zhiwu Xu, and Shengchao Qin. Demystifying "bad" error messages in data science libraries. In Proc. European Software Engineering Conference/International Symposium on the Foundations of Software Engineering (ESEC/FSE). ACM, Aug 2021. URL: https://doi.org/10.1145/3468264.3468560, doi:10.1145/3468264.3468560.

Tew2011

Allison Elliott Tew and Mark Guzdial. The FCS1: a language independent assessment of CS1 knowledge. In Proc. Technical Symposium on Computer Science Education (SIGCSE). ACM Press, 2011. URL: https://doi.org/10.1145/1953163.1953200, doi:10.1145/1953163.1953200.

Thongtanunam2016

Patanamon Thongtanunam, Shane McIntosh, Ahmed E. Hassan, and Hajimu Iida. Revisiting code ownership and its relationship with software quality in the scope of modern code review. In Proc. International Conference on Software Engineering (ICSE). ACM, May 2016. URL: https://doi.org/10.1145/2884781.2884852, doi:10.1145/2884781.2884852.

Tigina2023

Maria Tigina, Anastasiia Birillo, Yaroslav Golubev, Hieke Keuning, Nikolay Vyahhi, and Timofey Bryksin. Analyzing the quality of submissions in online programming courses. 2023. arXiv:2301.11158.

Tomasdottir2020

Kristín Fjóla Tómasdóttir, Maurício Aniche, and Arie van Deursen. The adoption of JavaScript linters in practice: a case study on ESLint. IEEE Transactions on Software Engineering, 46(8):863–891, Aug 2020. URL: https://doi.org/10.1109/tse.2018.2871058, doi:10.1109/tse.2018.2871058.

Tomassi2019

David Tomassi, Naji Dmeiri, Yichen Wang, Antara Bhowmick, Yen-Chuan Liu, Premkumar Devanbu, Bogdan Vasilescu, and Cindy Rubio-Gonzalez. BugSwarm: mining and continuously growing a dataset of reproducible failures and fixes. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2019. URL: https://doi.org/10.1109/icse.2019.00048, doi:10.1109/icse.2019.00048.

Torres2023

Adriano Torres, Sebastian Baltes, Christoph Treude, and Markus Wagner. Applying information theory to software evolution. 2023. arXiv:2303.13729.

Tourani2017

Parastou Tourani, Bram Adams, and Alexander Serebrenik. Code of conduct in open source projects. In Proc. International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, Feb 2017. URL: https://doi.org/10.1109/saner.2017.7884606, doi:10.1109/saner.2017.7884606.

Trang2021

Simon Trang and Welf H. Weiger. The perils of gamification: does engaging with gamified services increase users' willingness to disclose personal information? Computers in Human Behavior, 116:106644, Mar 2021. URL: https://doi.org/10.1016/j.chb.2020.106644, doi:10.1016/j.chb.2020.106644.

Tregubov2017

Alexey Tregubov, Barry Boehm, Natalia Rodchenko, and Jo Ann Lane. Impact of task switching and work interruptions on software development processes. In Proc. International Conference on Software and System Process (ICSSP). ACM, Jul 2017. URL: https://doi.org/10.1145/3084100.3084116, doi:10.1145/3084100.3084116.

2303.10131

Christoph Treude and Hideaki Hata. She elicits requirements and he tests: software engineering gender bias in large language models. 2023. arXiv:2303.10131.

Tshukudu2023

Ethel Tshukudu, Sue Sentance, Oluwatoyin Adelakun-Adeyemo, Brenda Nyaringita, Keith Quille, and Ziling Zhong. Investigating K-12 computing education in four African countries (Botswana, Kenya, Nigeria, and Uganda). ACM Transactions on Computing Education, 23(1):1–29, Jan 2023. URL: https://doi.org/10.1145/3554924, doi:10.1145/3554924.

Turcotte2020

Alexi Turcotte, Aviral Goel, Filip Křikava, and Jan Vitek. Designing types for R, empirically. Proceedings of the ACM on Programming Languages, 4(OOPSLA):1–25, Nov 2020. URL: https://doi.org/10.1145/3428249, doi:10.1145/3428249.

Vanhanen2007

Jari Vanhanen and Harri Korpi. Experiences of using pair programming in an agile project. In Proc. Hawaii International Conference on System Sciences (HICSS). IEEE, 2007. URL: https://doi.org/10.1109/hicss.2007.218, doi:10.1109/hicss.2007.218.

Vargovich2023

Joseph Vargovich, Fabio Santos, Jacob Penney, Marco A. Gerosa, and Igor Steinmacher. GiveMeLabeledIssues: an open source issue recommendation system. 2023. arXiv:2303.13418.

Vrandecic2023

Denny Vrandečić, Lydia Pintscher, and Markus Krötzsch. Wikidata: The Making Of. In Companion Proceedings of the ACM Web Conference 2023. ACM, Apr 2023. URL: https://doi.org/10.1145/3543873.3585579, doi:10.1145/3543873.3585579.

Vu2023

Duc-Ly Vu, Zachary Newman, and John Speed Meyers. Bad snakes: understanding and improving python package index malware scanning. In Proc. International Conference on Software Engineering (ICSE). 2023. URL: https://www.researchgate.net/publication/363888596_Bad_Snakes_Understanding_and_Improving_Python_Package_Index_Malware_Scanning.

Wang2016

Xinyu Wang, Sumit Gulwani, and Rishabh Singh. FIDEX: filtering spreadsheet data using examples. In Proc. International Conference on Object-Oriented Programming Systems Languages and Applications (OOPSLA). ACM, Oct 2016. URL: https://doi.org/10.1145/2983990.2984030, doi:10.1145/2983990.2984030.

Wang2020a

Peipei Wang, Chris Brown, Jamie A. Jennings, and Kathryn T. Stolee. An empirical study on regular expression bugs. In Proc. International Conference on Mining Software Repositories (MSR). ACM, Jun 2020. URL: https://doi.org/10.1145/3379597.3387464, doi:10.1145/3379597.3387464.

Wang2021

Jiawei Wang, Li Li, and Andreas Zeller. Restoring execution environments of Jupyter notebooks. 2021. arXiv:2103.02959.

Washburn2016

Michael Washburn, Pavithra Sathiyanarayanan, Meiyappan Nagappan, Thomas Zimmermann, and Christian Bird. What went right and what went wrong: an analysis of 155 postmortems from game development. In Proc. International Conference on Software Engineering (ICSE). ACM, May 2016. URL: https://doi.org/10.1145/2889160.2889253, doi:10.1145/2889160.2889253.

WeillTessier2021

Pierre Weill-Tessier, Alexandra Lucia Costache, and Neil C. C. Brown. Usage of the Java language by novices over time: implications for tool and language design. In Proc. Technical Symposium on Computer Science Education (SIGCSE). ACM, Mar 2021. URL: https://doi.org/10.1145/3408877.3432408, doi:10.1145/3408877.3432408.

Wessel2020

Mairieli Wessel, Alexander Serebrenik, Igor Wiese, Igor Steinmacher, and Marco A. Gerosa. Effects of adopting code review bots on pull requests to OSS projects. In Proc. International Conference on Software Maintenance and Evolution (ICSME). IEEE, Sep 2020. URL: https://doi.org/10.1109/icsme46990.2020.00011, doi:10.1109/icsme46990.2020.00011.

Wicherts2011

Jelte M. Wicherts, Marjan Bakker, and Dylan Molenaar. Willingness to share research data is related to the strength of the evidence and the quality of reporting of statistical results. PLoS ONE, 6(11):e26828, Nov 2011. URL: https://doi.org/10.1371/journal.pone.0026828, doi:10.1371/journal.pone.0026828.

Wilkerson2012

Jerod W. Wilkerson, Jay F. Nunamaker, and Rick Mercer. Comparing the defect reduction benefits of code inspection and test-driven development. IEEE Transactions on Software Engineering, 38(3):547–560, May 2012. URL: https://doi.org/10.1109/tse.2011.46, doi:10.1109/tse.2011.46.

Xu2015

Tianyin Xu, Long Jin, Xuepeng Fan, Yuanyuan Zhou, Shankar Pasupathy, and Rukma Talwadker. Hey, you have given me too many knobs!: understanding and dealing with over-designed configuration in system software. In Proc. International Symposium on the Foundations of Software Engineering (FSE). ACM, Aug 2015. URL: https://doi.org/10.1145/2786805.2786852, doi:10.1145/2786805.2786852.

Yan2023

Yutian Yan, Yunhui Zheng, Xinyue Liu, Nenad Medvidović, and Weihang Wang. AdHere: automated detection and repair of intrusive ads. In Proc. ICSE'23. 2023. URL: https://weihang-wang.github.io/papers/ICSE2023-AdHere.pdf.

Yang2022

Wenhua Yang, Chong Zhang, Minxue Pan, Chang Xu, Yu Zhou, and Zhiqiu Huang. Do developers really know how to use git commands? a large-scale study using stack overflow. ACM Transactions on Software Engineering and Methodology, 31(3):1–29, Jul 2022. URL: https://doi.org/10.1145/3494518, doi:10.1145/3494518.

Yasmin2020

Jerin Yasmin, Yuan Tian, and Jinqiu Yang. A first look at the deprecation of RESTful APIs: an empirical study. In Proc. International Conference on Software Maintenance and Evolution (ICSME). IEEE, Sep 2020. URL: https://doi.org/10.1109/icsme46990.2020.00024, doi:10.1109/icsme46990.2020.00024.

Yelam2021

Anil Yelam, Shibani Subbareddy, Keerthana Ganesan, Stefan Savage, and Ariana Mirian. CoResident evil: covert communication in the cloud with lambdas. In Proceedings of the Web Conference 2021. ACM, Apr 2021. URL: https://doi.org/10.1145/3442381.3450100, doi:10.1145/3442381.3450100.

Yin2011

Zuoning Yin, Ding Yuan, Yuanyuan Zhou, Shankar Pasupathy, and Lakshmi Bairavasundaram. How do fixes become bugs? In Proc. International Symposium on Foundations of Software Engineering/International Symposium on the Foundations of Software Engineering (SIGSOFT/FSE). ACM Press, 2011. URL: https://doi.org/10.1145/2025113.2025121, doi:10.1145/2025113.2025121.

Yuan2014

Ding Yuan, Yu Luo, Xin Zhuang, Guilherme Renna Rodrigues, Xu Zhao, Pranay U. Jain, and Michael Stumm. Simple testing can prevent most critical failures—an analysis of production failures in distributed data-intensive systems. In Proc. Symposium on Operating System Design and Implementation (OSDI). 2014. URL: https://doi.org/10.13140/2.1.2044.2889, doi:10.13140/2.1.2044.2889.

Zampetti2020

Fiorella Zampetti, Carmine Vassallo, Sebastiano Panichella, Gerardo Canfora, Harald Gall, and Massimiliano Di Penta. An empirical characterization of bad practices in continuous integration. Empirical Software Engineering, 25(2):1095–1135, Jan 2020. URL: https://doi.org/10.1007/s10664-019-09785-8, doi:10.1007/s10664-019-09785-8.

Zampetti2021

Fiorella Zampetti, Gianmarco Fucci, Alexander Serebrenik, and Massimiliano Di Penta. Self-admitted technical debt practices: a comparison between industry and open-source. Empirical Software Engineering, Sep 2021. URL: https://doi.org/10.1007/s10664-021-10031-3, doi:10.1007/s10664-021-10031-3.

Zavgorodniaia2021

Albina Zavgorodniaia, Raj Shrestha, Juho Leinonen, Arto Hellas, and John Edwards. Morning or evening? an examination of circadian rhythms of CS1 students. In Proc. International Conference on Software Engineering (ICSE). IEEE, May 2021. URL: https://doi.org/10.1109/icse-seet52601.2021.00036, doi:10.1109/icse-seet52601.2021.00036.

Zeller2009

Andreas Zeller. Why Programs Fail: A Guide to Systematic Debugging. Morgan Kaufmann, second edition, 2009. ISBN 9780123745156.

Zeller2021

Andreas Zeller, Rahul Gopinath, Marcel Böhme, Gordon Fraser, and Christian Holler. The Fuzzing Book. CISPA Helmholtz Center for Information Security, 2021. URL: https://www.fuzzingbook.org/.

Zhang2020

Haoxiang Zhang, Shaowei Wang, Tse-Hsun Chen, and Ahmed E. Hassan. Reading answers on stack overflow: not enough! IEEE Transactions on Software Engineering, pages 1–1, 2020. URL: https://doi.org/10.1109/tse.2019.2954319, doi:10.1109/tse.2019.2954319.

Zhang2021a

Jingxuan Zhang, He Jiang, Zhilei Ren, Tao Zhang, and Zhiqiu Huang. Enriching API documentation with code samples and usage scenarios from crowd knowledge. IEEE Transactions on Software Engineering, 47(6):1299–1314, Jun 2021. URL: https://doi.org/10.1109/tse.2019.2919304, doi:10.1109/tse.2019.2919304.

Zhang2021b

Haoxiang Zhang, Shaowei Wang, Tse-Hsun Chen, Ying Zou, and Ahmed E. Hassan. An empirical study of obsolete answers on stack overflow. IEEE Transactions on Software Engineering, 47(4):850–862, Apr 2021. URL: https://doi.org/10.1109/tse.2019.2906315, doi:10.1109/tse.2019.2906315.

Zhang2022a

Haiyin Zhang, Luís Cruz, and Arie van Deursen. Code smells for machine learning applications. In Proceedings of the 1st International Conference on AI Engineering: Software Engineering for AI. ACM, May 2022. doi:10.1145/3522664.3528620.

Zhao2023

Dehai Zhao, Zhenchang Xing, Xin Xia, Deheng Ye, Xiwei Xu, and Liming Zhu. Seehow: workflow extraction from programming screencasts through action-aware video analytics. 2023. arXiv:2304.14042.

Zhu2021

Wenhan Zhu and Michael W. Godfrey. Mea culpa: how developers fix their own simple bugs differently from other developers. In Proc. International Conference on Mining Software Repositories (MSR). IEEE, May 2021. URL: https://doi.org/10.1109/msr52588.2021.00065, doi:10.1109/msr52588.2021.00065.