User Tools

Site Tools


asking_and_answering_questions_during_a_programming_change_task

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision
Previous revision
asking_and_answering_questions_during_a_programming_change_task [2014/01/08 12:40]
yann
asking_and_answering_questions_during_a_programming_change_task [2018/03/04 02:53] (current)
Line 1: Line 1:
-====== ​Abstract ​======+====== ​Sillito, J.; Murphy, G. C. & De Volder, K. Asking and Answering Questions during a Programming Change Task. Transactions on Software Engineering,​ IEEE CS Press, 2008, 34, 434-451 ​====== 
 + 
 +===== Abstract ​=====
  
 Little is known about the specific kinds of questions programmers ask when evolving a code base and how well existing tools support those questions. To better support the activity of programming,​ answers are needed to three broad research questions: (1) what does a programmer need to know about a code base when evolving a software system? (2) how does a programmer go about finding that information?​ and (3) how well do existing tools support programmer?​s in answering those questions? We undertook two qualitative studies of programmers performing change tasks to provide answers to these questions. In this paper, we report on an analysis of the data from these two user studies. This paper makes three key contributions. The first contribution is a catalog of 44 types of questions programmers ask during software evolution tasks. The second contribution is a description of the observed behavior around answering those questions. The third contribution is a description of how existing deployed and proposed tools do, and do not, support answering programmers'​ questions. Little is known about the specific kinds of questions programmers ask when evolving a code base and how well existing tools support those questions. To better support the activity of programming,​ answers are needed to three broad research questions: (1) what does a programmer need to know about a code base when evolving a software system? (2) how does a programmer go about finding that information?​ and (3) how well do existing tools support programmer?​s in answering those questions? We undertook two qualitative studies of programmers performing change tasks to provide answers to these questions. In this paper, we report on an analysis of the data from these two user studies. This paper makes three key contributions. The first contribution is a catalog of 44 types of questions programmers ask during software evolution tasks. The second contribution is a description of the observed behavior around answering those questions. The third contribution is a description of how existing deployed and proposed tools do, and do not, support answering programmers'​ questions.
  
-====== Comments ​======+===== Comments =====
  
 //​Yann-Gaël Guéhéneuc,​ 2014/​01/​08//​ //​Yann-Gaël Guéhéneuc,​ 2014/​01/​08//​
  
 In this paper, the authors seek to provide the typical questions asked by developers during real change tasks. Knowing such questions could help designing tool support that is more efficient than today'​s tool support. It could also help refining models of program comprehension. Thus, it complements nicely previous works on models of program comprehension,​ programmers'​ questions, and empirical studies of change. This paper includes a very interesting list of references but unfortunately does not relate in details the cited previous work with the 44 questions discussed in the paper. In particular when it describes other works on programmers'​ questions, it does not explicitly relate previous works by: In this paper, the authors seek to provide the typical questions asked by developers during real change tasks. Knowing such questions could help designing tool support that is more efficient than today'​s tool support. It could also help refining models of program comprehension. Thus, it complements nicely previous works on models of program comprehension,​ programmers'​ questions, and empirical studies of change. This paper includes a very interesting list of references but unfortunately does not relate in details the cited previous work with the 44 questions discussed in the paper. In particular when it describes other works on programmers'​ questions, it does not explicitly relate previous works by:
-  ​Jonhson and Erdem who studied Usenet newsgroup and classified questions as goal oriented, symptom oriented, and system oriented; +  ​Jonhson and Erdem who studied Usenet newsgroup and classified questions as goal oriented, symptom oriented, and system oriented; 
-  ​Herbsleb and Kuwana who studied design meetings and classified questions according to their targets (evolve, task assignment, interface, realization,​ and identity), attribute (who, what, how, why, when), and lifecycle stages (requirements,​ design, implementation,​ maintenance);​ +  ​Herbsleb and Kuwana who studied design meetings and classified questions according to their targets (evolve, task assignment, interface, realization,​ and identity), attribute (who, what, how, why, when), and lifecycle stages (requirements,​ design, implementation,​ maintenance);​ 
-  ​Letovsky who studied programmers and classified their conjectures as why, how, what, whether, and discrepency;​ +  ​Letovsky who studied programmers and classified their conjectures as why, how, what, whether, and discrepency;​ 
-  ​Erdos and Sneed, based on their personal experience, who reported questions such as "where is a particular subroutine/​procedure invoked"​ and "what are the arguments and results of a given function";​ +  ​Erdos and Sneed, based on their personal experience, who reported questions such as "where is a particular subroutine/​procedure invoked"​ and "what are the arguments and results of a given function";​ 
-  ​Erdem et al. who reused their study of Usenet newsgroups and classified questions based on their topic, type, and relation; +  ​Erdem et al. who reused their study of Usenet newsgroups and classified questions based on their topic, type, and relation; 
-  ​Ko et al. who studied co-located software teams and classified questions as about writing code, submitting change, triaging bugs, reproducing a failure, understanding execution behaviour, reasoning about a design, and maintaining awareness;+  ​Ko et al. who studied co-located software teams and classified questions as about writing code, submitting change, triaging bugs, reproducing a failure, understanding execution behaviour, reasoning about a design, and maintaining awareness;
 It would have been interesting to relate all these different sets of questions and identify their intersections,​ redundancies,​ and gaps. In particular, there seems to be little interest about the behaviour... Other interesting questions pertain to the possible errors when mapping (top-down) or grouping (bottom-up) concepts and the stopping condition. It seems that few authors studied the errors that developers make when understanding programs (and why they make them). They also include relating the different sets of questions to comprehension theory/​models,​ such as the theory of cognitive support or distributed cognition. It would have been interesting to relate all these different sets of questions and identify their intersections,​ redundancies,​ and gaps. In particular, there seems to be little interest about the behaviour... Other interesting questions pertain to the possible errors when mapping (top-down) or grouping (bottom-up) concepts and the stopping condition. It seems that few authors studied the errors that developers make when understanding programs (and why they make them). They also include relating the different sets of questions to comprehension theory/​models,​ such as the theory of cognitive support or distributed cognition.
  
Line 21: Line 23:
  
 The authors considered a code source as a graph of entities and categorised the questions as finding focus points, expanding focus points, understanding a subgraph, and questions over groups of subgraphs. Surprisingly,​ they mentioned neither design patterns as typical cases of "​subgraph"​ nor Sim's structured transition graphs to explain the "​jumps"​ that developers make between categories. The 44 questions are as follows: The authors considered a code source as a graph of entities and categorised the questions as finding focus points, expanding focus points, understanding a subgraph, and questions over groups of subgraphs. Surprisingly,​ they mentioned neither design patterns as typical cases of "​subgraph"​ nor Sim's structured transition graphs to explain the "​jumps"​ that developers make between categories. The 44 questions are as follows:
-  ​Finding focus points+  ​Finding focus points
     - Which type represents this domain concept or this UI element or action? ​     - Which type represents this domain concept or this UI element or action? ​
     - Where in the code is the text in this error message or UI element?     - Where in the code is the text in this error message or UI element?
Line 27: Line 29:
     - Is there a precedent or exemplar for this?      - Is there a precedent or exemplar for this? 
     - Is there an entity named something like this in that unit (project, package, or class, say)?     - Is there an entity named something like this in that unit (project, package, or class, say)?
-  ​Expanding a focus point+  ​Expanding a focus point
     - What are the parts of this type?     - What are the parts of this type?
     - Which types is this type a part of?      - Which types is this type a part of? 
Line 43: Line 45:
     - What are the values of these arguments at runtime?     - What are the values of these arguments at runtime?
     - What data is being modified in this code?      - What data is being modified in this code? 
-  ​Understanding a subgraph+  ​Understanding a subgraph
     - How are instances of these types created and assembled? ​     - How are instances of these types created and assembled? ​
     - How are these types or objects related (whole-part)? ​     - How are these types or objects related (whole-part)? ​
Line 57: Line 59:
     - Under what circumstances is this method called or exception thrown? ​     - Under what circumstances is this method called or exception thrown? ​
     - What parts of this data structure are accessed in this code?     - What parts of this data structure are accessed in this code?
-  ​Questions over groups of subgraphs+  ​Questions over groups of subgraphs
     - How does the system behaviour vary over these types or cases?     - How does the system behaviour vary over these types or cases?
     - What are the differences between these files or types?     - What are the differences between these files or types?
asking_and_answering_questions_during_a_programming_change_task.1389184832.txt.gz · Last modified: 2018/03/04 02:53 (external edit)