ITU
ITU

Variability through the Eyes of the Programmer

Research output: Conference Article in Proceeding or Book/Report chapterArticle in proceedingsResearchpeer-review

Standard

Variability through the Eyes of the Programmer. / Melo, Jean; Batista Narcizo, Fabricio; Hansen, Dan Witzner; Brabrand, Claus; Wasowski, Andrzej.

2017 IEEE/ACM 25th International Conference on Program Comprehension (ICPC). IEEE, 2017. p. 34-44.

Research output: Conference Article in Proceeding or Book/Report chapterArticle in proceedingsResearchpeer-review

Harvard

Melo, J, Batista Narcizo, F, Hansen, DW, Brabrand, C & Wasowski, A 2017, Variability through the Eyes of the Programmer. in 2017 IEEE/ACM 25th International Conference on Program Comprehension (ICPC). IEEE, pp. 34-44, 2017 IEEE/ACM 25th International Conference on Program Comprehension, Buenos Aires, Argentina, 22/05/2017. https://doi.org/10.1109/ICPC.2017.34

APA

Melo, J., Batista Narcizo, F., Hansen, D. W., Brabrand, C., & Wasowski, A. (2017). Variability through the Eyes of the Programmer. In 2017 IEEE/ACM 25th International Conference on Program Comprehension (ICPC) (pp. 34-44). IEEE. https://doi.org/10.1109/ICPC.2017.34

Vancouver

Melo J, Batista Narcizo F, Hansen DW, Brabrand C, Wasowski A. Variability through the Eyes of the Programmer. In 2017 IEEE/ACM 25th International Conference on Program Comprehension (ICPC). IEEE. 2017. p. 34-44 https://doi.org/10.1109/ICPC.2017.34

Author

Melo, Jean ; Batista Narcizo, Fabricio ; Hansen, Dan Witzner ; Brabrand, Claus ; Wasowski, Andrzej. / Variability through the Eyes of the Programmer. 2017 IEEE/ACM 25th International Conference on Program Comprehension (ICPC). IEEE, 2017. pp. 34-44

Bibtex

@inproceedings{a4084045d9f644288d56e1e4ca6ddadf,
title = "Variability through the Eyes of the Programmer",
abstract = "Preprocessor directives (#ifdefs) are often used to implement compile-time variability, despite the critique that they increase complexity, hamper maintainability, and impair code comprehensibility. Previous studies have shown that the time of bug finding increases linearly with variability. However, little is known about the cognitive process of debugging programs with variability. We carry out an experiment to understand how developers debug programs with variability. We ask developers to debug programs with and without variability, while recording their eye movements using an eye tracker. The results indicate that debugging time increases for code fragments containing variability. Interestingly, debugging time also seems to increase for code fragments without variability in the proximity of fragments that do contain variability. The presence of variability correlates with increase in the number of gaze transitions between definitions and usages for fields and methods. Variability also appears to prolong the {"}initial scan{"} of the entire program that most developers initiate debugging with.",
keywords = "cognition, gaze tracking, human factors, program compilers, program debugging, software maintenance, code comprehensibility, code fragments, cognitive process, compile-time variability, debugging time, eye movements, eye tracker, gaze transitions, preprocessor directives, software maintainability, Complexity theory, Computer bugs, Debugging, Games, Open source software, Tools, Tracking, Eye Tracking, Highly-Configurable Systems, Preprocessors, Variability",
author = "Jean Melo and {Batista Narcizo}, Fabricio and Hansen, {Dan Witzner} and Claus Brabrand and Andrzej Wasowski",
year = "2017",
month = "5",
day = "1",
doi = "10.1109/ICPC.2017.34",
language = "English",
pages = "34--44",
booktitle = "2017 IEEE/ACM 25th International Conference on Program Comprehension (ICPC)",
publisher = "IEEE",
address = "United States",

}

RIS

TY - GEN

T1 - Variability through the Eyes of the Programmer

AU - Melo, Jean

AU - Batista Narcizo, Fabricio

AU - Hansen, Dan Witzner

AU - Brabrand, Claus

AU - Wasowski, Andrzej

PY - 2017/5/1

Y1 - 2017/5/1

N2 - Preprocessor directives (#ifdefs) are often used to implement compile-time variability, despite the critique that they increase complexity, hamper maintainability, and impair code comprehensibility. Previous studies have shown that the time of bug finding increases linearly with variability. However, little is known about the cognitive process of debugging programs with variability. We carry out an experiment to understand how developers debug programs with variability. We ask developers to debug programs with and without variability, while recording their eye movements using an eye tracker. The results indicate that debugging time increases for code fragments containing variability. Interestingly, debugging time also seems to increase for code fragments without variability in the proximity of fragments that do contain variability. The presence of variability correlates with increase in the number of gaze transitions between definitions and usages for fields and methods. Variability also appears to prolong the "initial scan" of the entire program that most developers initiate debugging with.

AB - Preprocessor directives (#ifdefs) are often used to implement compile-time variability, despite the critique that they increase complexity, hamper maintainability, and impair code comprehensibility. Previous studies have shown that the time of bug finding increases linearly with variability. However, little is known about the cognitive process of debugging programs with variability. We carry out an experiment to understand how developers debug programs with variability. We ask developers to debug programs with and without variability, while recording their eye movements using an eye tracker. The results indicate that debugging time increases for code fragments containing variability. Interestingly, debugging time also seems to increase for code fragments without variability in the proximity of fragments that do contain variability. The presence of variability correlates with increase in the number of gaze transitions between definitions and usages for fields and methods. Variability also appears to prolong the "initial scan" of the entire program that most developers initiate debugging with.

KW - cognition

KW - gaze tracking

KW - human factors

KW - program compilers

KW - program debugging

KW - software maintenance

KW - code comprehensibility

KW - code fragments

KW - cognitive process

KW - compile-time variability

KW - debugging time

KW - eye movements

KW - eye tracker

KW - gaze transitions

KW - preprocessor directives

KW - software maintainability

KW - Complexity theory

KW - Computer bugs

KW - Debugging

KW - Games

KW - Open source software

KW - Tools

KW - Tracking

KW - Eye Tracking

KW - Highly-Configurable Systems

KW - Preprocessors

KW - Variability

U2 - 10.1109/ICPC.2017.34

DO - 10.1109/ICPC.2017.34

M3 - Article in proceedings

SP - 34

EP - 44

BT - 2017 IEEE/ACM 25th International Conference on Program Comprehension (ICPC)

PB - IEEE

ER -

ID: 82128175