Ensuring the readability and comprehension of source code is key for effective software maintenance and evolution, particularly in tasks involving bug fixing, refactoring, and optimization. Previous studies highlight that challenges in maintenance and the emergence of certain bugs can be traced back to small code fragments called "Atoms of Confusion" (AC). While initial investigations identified these snippets in C++ code bases, subsequent studies have identified analogous structures in languages such as Java. Although numerous studies have delved into observing ACs in Java projects, there is a lack of studies focused on the Android ecosystem. This paper aims to address this gap by constructing a comprehensive dataset, which catalogs ACs and assesses their prevalence in the Android Open Source Project (AOSP). After analyzing over 125,000 source code files across 370 Git repositories, our findings reveal that more than 30% of Java files within the AOSP contain at least one AC, totaling over 320,000 recorded instances. This equates to one AC for approximately every 91 lines of code. Particularly, this dataset can be used to support further studies on shedding light on the ACs prevalence in the Android ecosystem, alongside their relation with traditional object-oriented software metrics (e.g., size, complexity, cohesion, and coupling), also recorded in the dataset. Using this dataset, researchers may provide valuable insights for developers and software engineers, emphasizing the need for strategies to mitigate the possible impact of ACs on software maintenance.

Software comprehension is essential to improve understanding and avoid mistakes in the software development lifecycle. Code confusion occurs when a developer and the computer reach different interpretations about the behavior of the same piece of code. Such pieces of code can be represented as small and isolated code patterns called Atoms of Confusion (ACs). In this study, we empirically investigated the effects of ACs in the software development lifecycle of 21 open-source Java projects. We built a dataset linking more than 8,000 commits, 4,000 reported issues, and 7,000 ACs from the subject projects. Our findings showed a positive correlation between the number of ACs and the number of reported bugs and improvements. We also investigated changes in commits, looking forward to gathering a better understanding of in what context ACs are removed. As each commit is linked to at least one reported issue (e.g., bug and improvement), we were able to compare the ratio of ACs removal regarding each kind of commit and use it as a proxy to indicate whether ACs are likely to be the cause behind a reported issue. We found a higher ratio of removed ACs in bug-fix and improvement commits than in the other kind of commits (task, sub-task, new feature, wish, and test) for 14 of the 19 studied projects, which had ACs removed in commits. Finally, to support our quantitative results, we conducted a qualitative analysis to understand better how often atoms of confusion contributed to the occurrence of a bug or improvement. We inspected ACs removed in these types of commits with up to ten lines removed, analyzing the source code, messages of each involved commit, and the title, description, and comments of related Jira issues. Out of a universe of 8,641 commits from 21 analyzed projects, 391 removed ACs. Among them, 53 met the condition for our qualitative analysis. In 7 of these commits, 9 removed ACs were likely to contributed directly to the occurrence of a bug or improvement. To the best of our knowledge, our research is the first to investigate the connection between Atoms of Confusion and the source of bugs or the cause of improvements in Java projects.

Program comprehension is a fundamental activity in software maintenance and evolution, impacting several tasks such as bug fixing, code reuse, and implementation of new features. The Atom of Confusion (AC) is considered the smallest piece of code that can confuse programmers, difficulting the correct understanding of the source code under consideration. Previous studies have shown that these atoms can significantly impact the presence of bugs in C++ projects and increase the time and effort to code understanding in C++ and Java programs. To gather more evidence about the diffusion of ACs in the Java ecosystem, we conduct a study to analyze the prevalence, co-occurrences (at the class level), and evolution of ACs in 27 long-lived Java libraries. To support our investigation, we developed an ACs automatic search tool, which found 11.404 occurrences in the studied libraries. The Conditional Operator and Logic as Control Flow ACs were the most prevalent among the 10 types of ACs assessed. Our findings show that Conditional Operator and Logic as Control Flow were more likely to co-occur in the same class. Finally, we observed that the prevalence of ACs did not decrease over time. On the contrary, in 13 libraries, the presence grew proportionally more than the size of the library in lines of code. Furthermore, in 15 libraries, the fraction of Java classes containing at least one AC also increases over time.