Navigate, Understand, Communicate: How Developers Locate Performance Bugs

Background: Performance bugs can lead to severe issues regarding computation efficiency, power consumption, and user experience. Locating these bugs is a difficult task because developers have to judge for every costly operation whether runtime is consumed necessarily or unnecessarily. Objective: We wanted to investigate how developers, when locating performance bugs, navigate through the code, understand the program, and communicate the detected issues. Method: We performed a qualitative user study observing twelve developers trying to fix documented performance bugs in two open source projects. The developers worked with a profiling and analysis tool that visually depicts runtime information in a list representation and embedded into the source code view. Results: We identified typical navigation strategies developers used for pinpointing the bug, for instance, following method calls based on runtime consumption. The integration of visualization and code helped developers to understand the bug. Sketches visualizing data structures and algorithms turned out to be valuable for externalizing and communicating the comprehension process for complex bugs. Conclusion: Fixing a performance bug is a code comprehension and navigation problem. Flexible navigation features based on executed methods and a close integration of source code and performance information support the process.

[1]  Robert DeLine,et al.  Let's go to the whiteboard: how and why software developers use drawings , 2007, CHI.

[2]  Helen Sharp,et al.  Knowledge transfer in pair programming: An in-depth analysis , 2015, Int. J. Hum. Comput. Stud..

[3]  Carolyn B. Seaman,et al.  Qualitative Methods in Empirical Studies of Software Engineering , 1999, IEEE Trans. Software Eng..

[4]  Fabian Beck,et al.  Rethinking User Interfaces for Feature Location , 2015, 2015 IEEE 23rd International Conference on Program Comprehension.

[5]  Gail C. Murphy,et al.  Asking and Answering Questions during a Programming Change Task , 2008, IEEE Transactions on Software Engineering.

[6]  J. Sweller.  Implications of Cognitive Load Theory for Multimedia Learning , 2005, The Cambridge Handbook of Multimedia Learning.

[7]  Robert W. Bowdidge,et al.  Why don't software developers use static analysis tools to find bugs? , 2013, 2013 35th International Conference on Software Engineering (ICSE).

[8]  Ted Boren,et al.  Thinking aloud: reconciling theory and practice , 2000 .

[9]  A. Strauss,et al.  Basics of Qualitative Research , 1992 .

[10]  Janice Singer,et al.  An examination of software engineering work practices , 2010, CASCON.

[11]  John Sweller,et al.  The Cambridge Handbook of Multimedia Learning: The Split-Attention Principle in Multimedia Learning , 2005 .

[12]  John Sweller,et al.  The Split-Attention Principle in Multimedia Learning , 2021, The Cambridge Handbook of Multimedia Learning.

[13]  E. Tufte.  Beautiful Evidence , 2006 .

[14]  Rainer Koschke,et al.  How do professional developers comprehend software? , 2012, 2012 34th International Conference on Software Engineering (ICSE).

[15]  Jan Chong,et al.  The Social Dynamics of Pair Programming , 2007, 29th International Conference on Software Engineering (ICSE'07).

[16]  Martin P. Robillard,et al.  The Emergent Structure of Development Tasks , 2005, ECOOP.

[17]  K. Charmaz,et al.  Constructing Grounded Theory , 2014 .

[18]  Oscar Nierstrasz,et al.  Augmenting static source views in IDEs with dynamic metrics , 2009, 2009 IEEE International Conference on Software Maintenance.

[19]  B. Chadwick,et al.  Analysing and presenting qualitative data , 2008, BDJ.

[20]  Xin-She Yang,et al.  Introduction to Algorithms , 2021, Nature-Inspired Optimization Algorithms.

[21]  Naomi Miyake,et al.  Constructive Interaction and the Iterative Process of Understanding , 1986, Cogn. Sci..

[22]  Laurie A. Williams,et al.  Strengthening the Case for Pair Programming , 2000, IEEE Softw..

[23]  Rachel K. E. Bellamy,et al.  How Programmers Debug, Revisited: An Information Foraging Theory Perspective , 2013, IEEE Transactions on Software Engineering.

[24]  Shan Lu,et al.  Understanding and detecting real-world performance bugs , 2012, PLDI.

[25]  Shan Lu,et al.  Toddler: Detecting performance problems via similar memory-access patterns , 2013, 2013 35th International Conference on Software Engineering (ICSE).

[26]  Janice Singer,et al.  An examination of software engineering work practices , 1997, CASCON.

[27]  Fabian Beck,et al.  Visual monitoring of numeric variables embedded in source code , 2013, 2013 First IEEE Working Conference on Software Visualization (VISSOFT).

[28]  Robert DeLine,et al.  Information Needs in Collocated Software Development Teams , 2007, 29th International Conference on Software Engineering (ICSE'07).

[29]  Neville Churcher,et al.  In Situ Software Visualisation , 2010, 2010 21st Australian Software Engineering Conference.

[30]  Norsaremah Salleh,et al.  An empirical study of the effects of personality in pair programming using the five-factor model , 2009, ESEM 2009.

[31]  Stephan Diehl,et al.  Sketches and diagrams in practice , 2014, Software Engineering & Management.

[32]  Franz Zieris,et al.  On knowledge transfer skill in pair programming , 2014, ESEM '14.

[33]  David Lorge Parnas,et al.  Software aging , 1994, Proceedings of 16th International Conference on Software Engineering.

[34]  Martin P. Robillard,et al.  How effective developers investigate source code: an exploratory study , 2004, IEEE Transactions on Software Engineering.

[35]  Pablo Romero,et al.  Pair programming and the mysterious role of the navigator , 2008, Int. J. Hum. Comput. Stud..

[36]  Brad A. Myers,et al.  An Exploratory Study of How Developers Seek, Relate, and Collect Relevant Information during Software Maintenance Tasks , 2006, IEEE Transactions on Software Engineering.