Code smells are recurring design and implementation issues that degrade software quality and maintainability. While several studies have examined code smells in Android applications, there is a lack of publicly available datasets that systematically capture and quantify them. This paper introduces SMELLDroid, a large-scale dataset designed to support empirical studies on code smells within the Android ecosystem. The dataset comprises code smells extracted from 38,704 Android applications, including 29,201 malware apps and 9,503 benign apps. SMELLDroid encompasses seven code smell types—four object-oriented (BLOB, CC, LM, SAK) and three Android-specific (HAS, HBR, HSS)—with quantitative indicators representing their occurrence across applications. This dataset enables researchers to pursue multiple directions, such as quantifying smell prevalence, analyzing relationships among smell categories, and comparing code quality characteristics between benign and malware apps.

While design patterns are widely used to enhance software quality, there is a need for empirical evidence to understand their impact on software maintainability. This study empirically investigates the maintainability index of object-oriented design patterns at three levels: design, pattern category, and individual patterns. Data were collected from five real-world software systems, which include a total of 63 instances of design patterns spanning 17 GoF design patterns. At the design level, the results show that classes implementing design patterns have a statistically significant higher maintainability index than those that do not. At the pattern category level, creational and structural design patterns exhibit a higher maintainability index compared to behavioral patterns. Finally, at the pattern level, the Builder, State, and Adapter patterns rank as the top three in terms of maintainability index.

Android malware is an ongoing threat to billions of smart devices’ security, ranging from mobile phones to car infotainment systems. Despite numerous approaches and previous studies to develop solutions for detecting and preventing Android malware, the rapid continuous development of new malware variants requires a careful reconsideration and the development of effective methods to identify malware families given a meager number of malware instances. In this paper, we present DroidMalVet, a novel Android malware family classification and detection approach that does not require to perform complex program analyses or utilize large feature sets. DroidMalVet is the first to use a promising, diverse, and small set of software metrics as features in a supervised learning platform to classify and detect various Android malware families. Our extensive empirical evaluations on two large public malware datasets show that DroidMalVet accurately detects both small and large malware families with F-Score accuracy of 94.4% and 96%, and AUC equal to 99.5% and 99.7% on the malware families in Drebin and AMD datasets, respectively. Moreover, our results demonstrate the superior performance of DroidMalVet in detecting small families (i.e., families with few samples). DroidMalVet complements existing approaches and presents an early warning tool for detecting known and emerging malware families.

Code cloning has been a typical practice during software development, by which code fragments are reused with or without changes by copying and pasting. It has been a questionable issue whether cloning has a destructive impact or not on software development and the quality of the delivered software. This paper empirically investigates the relationship between code clones and fault density of object-oriented classes. More than 3000 classes from five open source software systems were analyzed. The results suggest that classes that have clones were less fault dense on average than the classes that do not have clones. However, there was no association between intra/inter-class clone fragments within a class and its fault density. The results also indicate that among the groups of classes that have only one type of clones, the group of classes with Type III clones was the least fault dense. Minor, although statistically significant, correlations were observed between many code clone metrics and class fault density. Furthermore, the fault density predictive powers of these metrics were found to be almost the same. However, no improvement in the accuracy of fault density prediction models was observed when these metrics were used as inputs.

This paper reports and discusses the results of an assessment study, which aimed to determine the extent to which the voting ensemble model offers reliable and improved estimation accuracy over five individual models (MLP, RBF, RT, KNN and SVR) in estimating software development effort. Five datasets were used for this purpose. The results confirm that individual models are not reliable as their performance is inconsistence and unstable across different datasets. However, the ensemble model provides more reliable performance than individual models. In three out of the five datasets that were used in this study, the ensemble model outperformed the individual models. In the other two datasets, the ensemble model achieved the second best performance, which was still very competitive as there was no statistically significant difference between it and the best models in these two datasets.

SUMMARY Refactoring improves software quality by improving the design of existing code through changing its internal structure while preserving its behavior. Improving one quality attribute may impair other quality attributes. A number of refactoring methods were proposed specifically for aspect‐oriented systems. However, there are no guidelines to help aspect‐oriented software designer decide which refactoring methods to apply to optimize a software system with regard to certain design goals. In this paper, we propose a taxonomy/classification of refactoring methods for aspect‐oriented programming based on their measurable effect on software quality attributes using six open‐source aspect‐oriented software systems. Copyright © 2011 John Wiley & Sons, Ltd.

ABSTRACT Software systems are subject to series of changes during their evolution as they move from one release to the next. The change histories of software systems hold useful information that describes how artifacts evolved. Evolution‐based metrics, which are the means to quantify the change history, are potentially good indicators of the changes in a software system. The objective of this paper is to derive and validate (theoretically and empirically) a set of evolution‐based metrics as potential indicators of the change‐prone classes of an object‐oriented system when moving from one release to the next. Release‐by‐release statistical prediction models were built in different ways. The results indicate that the proposed evolution‐based metrics measure different dimensions from those of typical product metrics. Additionally, several evolution‐based metrics were found to be correlated with the change‐proneness of classes. Moreover, the results indicate that more accurate prediction of class change‐proneness is achieved when the evolution‐based metrics are combined with product metrics. Copyright © 2012 John Wiley & Sons, Ltd.

In object-oriented designs, packages represent important high-level organization units that group classes. This paper explores the relationships between five package-level metrics and the average effort required to understand a package in object-oriented design. These metrics measure different structural properties of a package such as size, coupling and stability. A case study was conducted using eighteen packages taken from two open source software systems. Correlation, collinearity, and multivariate regression analyses were performed. The results obtained from this study indicate statistically significant correlation between most of the metrics and understandability of a package.

Identifying faulty classes in object-oriented software is one of the important software quality assurance activities. This paper empirically investigates the application of two popular ensemble techniques (bagging and boosting) in identifying faulty classes in object-oriented software, and evaluates the extent to which these ensemble techniques offer an increase in classification accuracy over single classifiers. As base classifiers, we used multilayer perceptron, radial basis function network, Bayesian belief network, nave Bayes, support vector machines, and decision tree. The experiment was based on well-known and respected NASA dataset. The results indicate that bagging and boosting yield improved classification accuracy over most of the investigated single classifiers. In some cases, bagging outperforms boosting, while in some other cases, boosting outperforms bagging. However, in case of support vector machines, neither bagging nor boosting improved its classification accuracy.

Stability is one of the most desirable quality attributes of any software design. The stability of a class diagram indicates its resistance to interclass propagation of changes that the diagram would have when it is modified. This short paper discusses with examples the impact of four structural design patterns (adapter, bridge, composite and facade) on the stability of class diagrams

The structural stability of an object-oriented design (OOD) refers to the extent to which the structure of the design is preserved throughout the evolution of the software from one release to the next. This paper empirically investigates potential indicators of measures of structural stability of OODs. Both product-related and process-related indicators are considered. These indicators were evaluated through a case study that involves 13 successive releases of Apache Ant. The results showed that each one of the stability metrics is significantly correlated with at least one of the investigated indicators. To make early predictions of the values of each one of the stability metrics, statistically significant regression models were constructed from subsets of the investigated indicators