Evaluating the Code Comprehension of Novices with Eye Tracking
Resumo
A compreensão de código é essencial para a evolução do software, mas pode ser prejudicada por problemas estruturais no código. Apesar de sua importância, pesquisadores muitas vezes dependem de métricas de código estático para investigar a compreensão do código, sem considerar aspectos dinâmicos, como o esforço visual envolvido. Portanto, nosso objetivo é preencher essa lacuna examinando a compreensão do código usando métricas de rastreamento ocular. Realizamos três estudos controlados de rastreamento ocular com 128 novatos em três linguagens de programação distintas, C, Python e Java, utilizando construções com diferentes níveis de granularidade, ou seja, átomos de confusão, refatorações e anotações #ifdef. Em relação aos átomos de confusão, descobrimos que a versão esclarecida do código reduziu o tempo e o número de tentativas em 38,6% e 28%, respectivamente. O uso da refatoração Extract Method reduziu significativamente o tempo de duas tarefas em 70% a 78,8%, enquanto aumentou a precisão de três tarefas em 20% a 34,4%. O uso de anotações #ifdef apresentou reduções na região modificada de 46,9% no tempo, 44,7% na duração da fixação, 48,4% no número de fixações e 60,5% no número de regressões. Além disso, também identificamos padrões em nossos dados observando várias transições visuais avançando e retrocedendo entre elementos de código específicos, o que nos permitiu inferir confusão no código. Esses resultados fornecem informações valiosas para educadores, profissionais e pesquisadores sobre determinadas transformações e seu potencial para facilitar ou dificultar a compreensão do código. O estudo também destaca o potencial de métricas visuais para revelar o impacto de transformações que não podem ser capturadas por métricas de código estático. Nossos resultados também abrem caminho para o desenvolvimento de ferramentas mais avançadas que rastreiam os movimentos oculares dos desenvolvedores e os auxiliam com sugestões úteis.
Referências
Cedrim, D., Garcia, A., Mongiovi, M., Gheyi, R., Sousa, L., de Mello, R., Fonseca, B., Ribeiro, M., and Chávez, A. (2017). Understanding the Impact of Refactoring on Smells: A Longitudinal Study of 23 Software Projects. ESEC/FSE’17, page 465–475.
da Costa, J. A. S., Gheyi, R., Castor, F., de Oliveira, P. R. F., Ribeiro, M., and Fonseca, B. (2023). Seeing Confusion through a New Lens: on the Impact of Atoms of Confusion on Novices’ Code Comprehension. Empirical Software Engineering, to appear(to appear):to appear.
da Costa, J. A. S., Gheyi, R., Ribeiro, M., Apel, S., Alves, V., Fonseca, B., Medeiros, F., and Garcia, A. (2021). Evaluating Refactorings for Disciplining ifdef Annotations: An Eye Tracking Study with Novices. Empirical Software Engineering, 26(5):1–35.
da Costa et al. (2023). “Supplementary Material for the Thesis (Artifacts)”. At https://github.com/josealdo/material-complementar-tese.
de Oliveira, B., Ribeiro, M., da Costa, J. A. S., Gheyi, R., Amaral, G., de Mello, R., Oliveira, A., Garcia, A., Bonifácio, R., and Fonseca, B. (2020). Atoms of Confusion: The Eyes Do Not Lie. SBES’20, pages 243–252.
Fenske, W., Krüger, J., Kanyshkova, M., and Schulze, S. (2020). ifdef Directives and Program Comprehension: The Dilemma between Correctness and Preference. ICSME’20.
Fowler, M. (1999). Refactoring: Improving the Design of Existing Code. Boston, MA, USA: Addison-Wesley/Longman.
Gopstein, D., Iannacone, J., Yan, Y., DeLong, L., Zhuang, Y., Yeh, M. K.-C., and Cappos, J. (2017). Understanding Misunderstandings in Source Code. ESEC/FSE’17, pages 129–139.
Langhout, C. and Aniche, M. (2021). Atoms of Confusion in Java. (ICPC’21), pages 25–35. IEEE.
Liebig, J., Kästner, C., and Apel, S. (2011). Analyzing the discipline of preprocessor annotations in 30 million lines of C code. AOSD’11, pages 191–202.
Malaquias, R., Ribeiro, M., Bonifácio, R., Monteiro, E., Medeiros, F., Garcia, A., and Gheyi, R. (2017). The Discipline of Preprocessor-Based Annotations – Does ifdef TAG n’t endif Matter. ICPC’17, pages 297–307. IEEE.
Medeiros, F., Lima, G., Amaral, G., Apel, S., Kästner, C., Ribeiro, M., and Gheyi, R. (2019). An Investigation of Misunderstanding Code Patterns in C Open-source Software Projects. Empirical Software Engineering, 24(4):1693–1726.
Medeiros, F., Ribeiro, M., Gheyi, R., Apel, S., Kästner, C., Ferreira, B., Carvalho, L., and Fonseca, B. (2018). Discipline matters: Refactoring of preprocessor directives in the ifdef hell. IEEE Transactions on Software Engineering, 44(5):453–469.
Medeiros, F., Rodrigues, I., Ribeiro, M., Teixeira, L., and Gheyi, R. (2015). An empirical study on configuration-related issues: investigating undeclared and unused identifiers. In (GPCE’15), pages 35–44.
Mongiovi, M., Gheyi, R., Soares, G., Ribeiro, M., Borba, P., and Teixeira, L. (2018). Detecting overly strong preconditions in refactoring engines. IEEE Transactions on Software Engineering, 44(5):429–452.
Schulze, S., Liebig, J., Siegmund, J., and Apel, S. (2013). Does the Discipline of Preprocessor Annotations Matter?: A Controlled Experiment. GPCE ’13, pages 65–74.
Sharafi, Z., Shaffer, T., Sharif, B., and Guéhéneuc, Y.-G. (2015). Eye-tracking Metrics in Software Engineering. APSEC’15, pages 96–103. IEEE.
Soares, G., Gheyi, R., and Massoni, T. (2013). Automated behavioral testing of refactoring engines. IEEE Transactions on Software Engineering, 39(2):147–162.
Yeh, M. K.-C., Yan, Y., Zhuang, Y., and DeLong, L. A. (2021). Identifying Program Confusion Using Electroencephalogram Measurements. Behaviour & Information Technology, pages 1–18.
