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.

Buggy software impacts people's lives and businesses. Nowadays, a huge portion of a software project's cost is spent on debugging (finding and fixing bugs). Therefore, reducing the time needed to release new software versions free from bugs becomes crucial. Continuous delivery (CD) arises as an alternative to traditional software release engineering by providing the capability to faster and continuously release software to customers through automated pipelines. Previous studies claim that CD adoption leads to a reduction in the software release cycle time, including the time lag to fix reported bugs (bug-fixing time) and apply correction patches in the affected versions. However, there is a lack of empirical evidence supporting (or not) this claim. To fulfill this gap, we conducted an empirical study to evaluate the impact of CD adoption in the bug-fixing time. We study 25 open-source projects comparing the bug-fixing time before and after adopting CD. Our results show that bug-fixing time after CD adoption becomes shorter (with statistical significance) than the bug-fixing time before CD adoption.

Software unbundling consists of dividing an existing software artifact into smaller ones. Unbundling can be useful for removing clutter from the original application or separating different features that may not share the same purpose, or simply for isolating an emergent functionality that merits to be an application on its own. This phenomenon is frequent with mobile apps and it is also propagating to APIs. This paper proposes a first empirical study on unbundling to understand its effects on popular APIs. We explore the possibilities of splitting libraries into 2 or more bundles based on the use that their client projects make of them. We mine over than 71,000 client projects of 10 open source APIs and automatically generate 2,090 sub-APIs to then study their properties. We find that it is possible to have sets of different ways of using a given API and to unbundle it accordingly; the bundles can vary their representativeness and uniqueness, which is analyzed thoroughly in this study.