Design Smells Research Articles

Machine Learning-Based Methods for Code Smell Detection: A Survey

Code smells are early warning signs of potential issues in software quality. Various techniques are used in code smell detection, including the Bayesian approach, rule-based automatic antipattern detection, antipattern identification utilizing B-splines, Support Vector Machine direct, SMURF (Support Vector Machines for design smell detection using relevant feedback), and immune-based detection strategy. Machine learning (ML) has taken a great stride in this area. This study includes relevant studies applying ML algorithms from 2005 to 2024 in a comprehensive manner for the survey to provide insight regarding code smell, ML algorithms frequently applied, and software metrics. Forty-two pertinent studies allow us to assess the efficacy of ML algorithms on selected datasets. After evaluating various studies based on open-source and project datasets, this study evaluated additional threats and obstacles to code smell detection, such as the lack of standardized code smell definitions, the difficulty of feature selection, and the challenges of handling large-scale datasets. The current studies only considered a few factors in identifying code smells, while in this study, several potential contributing factors to code smells are included. Several ML algorithms are examined, and various approaches, datasets, dataset languages, and software metrics are presented. This study provides the potential of ML algorithms to produce better results and fills a gap in the body of knowledge by providing class-wise distributions of the ML algorithms. Support Vector Machine, J48, Naive Bayes, and Random Forest models are the most common for detecting code smells. Researchers can find this study helpful in better anticipating and taking care of software development design and implementation issues. The findings from this study, which highlight the practical implications of ML algorithms in software quality improvement, will help software engineers fix problems during software design and development to ensure software quality.

Design smells in multi-language systems and bug-proneness: a survival analysis

Design smells in multi-language systems and bug-proneness: a survival analysis

Mobile-UI-Repair: a deep learning based UI smell detection technique for mobile user interface

The graphical user interface (GUI) in mobile applications plays a crucial role in connecting users with mobile applications. GUIs often receive many UI design smells, bugs, or feature enhancement requests. The design smells include text overlap, component occlusion, blur screens, null values, and missing images. It also provides for the behavior of mobile applications during their usage. Manual testing of mobile applications (app as short in the rest of the document) is essential to ensuring app quality, especially for identifying usability and accessibility that may be missed during automated testing. However, it is time-consuming and inefficient due to the need for testers to perform actions repeatedly and the possibility of missing some functionalities. Although several approaches have been proposed, they require significant performance improvement. In addition, the key challenges of these approaches are incorporating the design guidelines and rules necessary to follow during app development and combine the syntactical and semantic information available on the development forums. In this study, we proposed a UI bug identification and localization approach called Mobile-UI-Repair (M-UI-R). M-UI-R is capable of recognizing graphical user interfaces (GUIs) display issues and accurately identifying the specific location of the bug within the GUI. M-UI-R is trained and tested on the history data and also validated on real-time data. The evaluation shows that the average precision is 87.7% and the average recall is 86.5% achieved in the detection of UI display issues. M-UI-R also achieved an average precision of 71.5% and an average recall of 70.7% in the localization of UI design smell. Moreover, a survey involving eight developers demonstrates that the proposed approach provides valuable support for enhancing the user interface of mobile applications. This aids developers in their efforts to fix bugs.

Resource Allocation Modeling Framework to Refactor Software Design Smells

The domain to study design flaws in the software environment has created enough opportunity for the researchers. These design flaws i.e., code smells, were seen hindering the quality aspects of the software in many ways. Once detected, the segment of the software which was found to be infected with such a flaw has to be passed through some refactoring steps in order to remove it. To know about their working phenomenon in a better way, authors have innovatively talked about the smell detection mechanism using the NHPP modeling framework. Further the authors have also chosen to investigate about the amount of resources/efforts which should be allotted to various code smell categories. The authors have developed an optimization problem for the said purpose which is being validated on the real-life smell data set belonging to an open-source software system. The obtained results are in acceptable range and are justifying the applicability of the model.

Prioritization of god class design smell: A multi-criteria based approach

Context: Design smell Prioritization is a significant activity that tunes the process of software quality enhancement and raises its life cycle. Objective: A multi-criteria merge strategy for Design Smell prioritization is described. The strategy is exemplified with the case of God Class Design Smell. Method: An empirical adjustment of the strategy is performed using a dataset of 24 open source projects. Empirical evaluation was conducted in order to check how is the top ranked God Classes obtained by the proposed technique compared against the top ranked God class according to the opinion of developers involved in each of the projects in the dataset. Results: Results of the evaluation show the strategy should be improved. Analysis of the differences between projects where respondents answer correlates with the strategy and those projects where there is no correlation should be done.

Exploring Design smells for smell-based defect prediction

Defect prediction is commonly used to reduce the effort from the testing phase of software development. A promising strategy is to use machine learning techniques to predict which software components may be defective. Features are key factors to the prediction’s success, and thus extracting significant features can improve the model’s accuracy. In particular, code smells are a category of those features that have been shown to improve the prediction performance significantly. However, Design code smells, a state-of-the-art collection of code smells based on the violations of the object-oriented programming principles, have not been studied in the context of defect prediction. In this paper, we study the performance of defect prediction models by training multiple classifiers for 97 real projects. We compare using Design code smells as features and using other Traditional smells from the literature and both. Moreover, we cluster and analyze the models’ performance based on the categories of Design code smells. We conclude that the models trained with both the Design code smells and the smells from the literature performed the best, with an improvement of 4.1% for the AUC score, compared to models trained with only Traditional smells. Consequently, Design smells are a good addition to the smells commonly studied in the literature for defect prediction.

Prioritization of model smell refactoring using a covariance matrix-based adaptive evolution algorithm

The refactoring process enhances the software design by modifying the structure of design parts impaired with model smells without altering the overall software behavior. However, handling these smells without proper prioritization will not produce the anticipated effects. In this paper, we solve the prioritization of the model smell refactoring using a multi-objective optimization (MOO) algorithm called the multi-objective (MO) covariance matrix adaptation evolution strategy (MO CMA-ES). Our formulation relies on the refactoring of unified modeling language (UML) class diagrams to mitigate the negative effect of design smells. We treat the prioritization problem as a real-valued MOO where we propose novel data encoding procedures. We use two conflicting objectives, quality, and maintainability , to balance the refactoring. We first build a new solution representation that guarantees smell fixing and eliminates the rejection limitation. Furthermore, we suggest a custom mapping scheme to properly encode real-valued quantities using unique representations. For performance evaluation purposes, we developed a large custom dataset with more than 30,000 class records, using seven popular open-source software projects. A novel relative coverage metric is proposed to mitigate the limitations associated with the standard coverage. For benchmarking purposes, we also consider an improved version of the nondominated sorting genetic algorithm (NSGA-II(. The reported performance scores confirm the superiority of the MO CMA-ES algorithm over NSGA-II. The former successfully identified the refactoring sequences that lead to the best improvements in software quality and maintainability while it is able to fix all identified design smells. These improvements are quantified in terms of hypervolume, coverage, spacing metrics, and execution time. The MO CMA-ES attained the highest average maximum quality score of 1149 while keeping the average maintainability at the lowest score of 13.8. In all experiment settings, the proposed solution leads to longer refactoring sequences at no additional computational cost.

Multi-language design smells: a backstage perspective

Multi-language design smells: a backstage perspective

OPLA-Tool-ASP: a Tool to Prevent Architectural Smells in Search-based Product Line Architecture Design

Search-based algorithms have been successfully employed in Product Line Architecture (PLA) design in the seminal approach named Multi-Objective Approach for Product-Line Architecture Design (MOA4PLA). This approach generates a set of alternative PLA designs, which optimize different architectural properties. In addition to these properties, the alternative PLA designs should have as few architectural smells as possible. Architectural smells can negatively impact PLA variability, PLA extensibility, SPL maintainability, and other non-functional attributes. However, one of the main findings of a previous study is that the tool that automates the application of MOA4PLA adversely introduces architectural smells in the automatically generated solutions. In this work, we present OPLA-Tool-ASP, which is a tool that implements guidelines to detect and prevent the architectural smells Unused Interface, Unused Brick, Concern Overload, and Link Overload in the context of MOA4PLA. An empirical study was carried out to assess the effectiveness of OPLA-Tool-ASP in preventing the aforementioned smells in the resulting PLA designs. The obtained results pointed out that the proposed tool is effective in both preventing the smells and improving the architectural properties selected for optimization.

A comparison of machine learning algorithms on design smell detection using balanced and imbalanced dataset: A study of God class

Design smell detection has proven to be a significant activity that has an aim of not only enhancing the software quality but also increasing its life cycle. This work investigates whether machine learning approaches can effectively be leveraged for software design smell detection. Additionally, this paper provides a comparatively study, focused on using balanced datasets, where it checks if avoiding dataset balancing can be of any influence on the accuracy and behavior during design smell detection. A set of experiments have been conducted-using 28 Machine Learning classifiers aimed at detecting God classes. This experiment was conducted using a dataset formed from 12,587 classes of 24 software systems, in which 1,958 classes were manually validated. Ultimately, most classifiers obtained high performances,-with Cat Boost showing a higher performance. Also, it is evident from the experiments conducted that data balancing does not have any significant influence on the accuracy of detection. This reinforces the application of machine learning in real scenarios where the data is usually imbalanced by the inherent nature of design smells. Machine learning approaches can effectively be used as a leverage for God class detection. While in this paper we have employed SMOTE technique for data balancing, it is worth noting that there exist other methods of data balancing and with other design smells. Furthermore, it is also important to note that application of those other methods may improve the results, in our experiments SMOTE did not improve God class detection. The results are not fully generalizable because only one design smell is studied with projects developed in a single programming language, and only one balancing technique is used to compare with the imbalanced case. But these results are promising for the application in real design smells detection scenarios as mentioned above and the focus on other measures, such as Kappa, ROC, and MCC, have been used in the assessment of the classifier behavior.

Software refactoring side effects

AbstractSoftware refactoring solutions aim at mitigating the negative effects of code and design smells on the overall software quality. Many efforts have been exerted to improve the software refactoring process. However, most of these efforts, despite their contributions, overlooked the side effects of the identified refactoring opportunities that may lead to new smells that will go unnoticed. This paper addresses the side effects of software refactoring and proposes sound solutions for handling them. Unlike current practices in software maintenance, we recommend three different approaches to handle the refactoring side effects. In the first approach, called the baseline, we opt to ignore the smells, caused by refactoring, while executing the identified refactoring decisions. In the second one, refactoring decisions are continually updated to fix all smells caused by side effects. In the last approach, only a subset of these smells is appended to the original smell sequence during the execution of the refactoring decisions. Thanks to the proposed approaches, optimal refactoring decisions are identified using a multi‐objective (MO) optimization algorithm commonly known as the MO covariance matrix adaptation evolution strategy (MO‐CMA‐ES). Experiment results corroborate our assumptions and show the superiority of the second approach over the other ones.

Temporal convolutional networks for just-in-time design smells prediction using fine-grained software metrics

Software systems quality is strongly influenced by the presence of design problems and wrong constructs introduced during software evolution. Design smells are recognized to be indicators of such problems since their presence can indicate violations of the fundamental software design principles. This explains the interest of software researchers and developers in new approaches performing design smell early detection. In this paper, the adoption of a just-in-time design smell prediction approach is proposed. The approach uses a variant of Temporal Convolutional Networks (TCN) to predict the presence of design smells before they are introduced in the model. In comparison to other studies, in the proposed approach we focus on commit-level fine-grained product metrics and process metrics (i.e., ownership and seniority) to make deep neural networks training suitable. The validation is performed on a large dataset composed of six open source systems. The results show good prediction performance for some design smells and for all the considered design smells categories. The experiment performed shows that, with respect to baseline prediction models (i.e., LSTM,CNN and RF), the proposed TCN variant trained on the identified metrics, gives better results.

Measuring affective states from technical debt

ContextSoftware engineering is a human activity. Despite this, human aspects are under-represented in technical debt research, perhaps because they are challenging to evaluate.ObjectiveThis study’s objective was to investigate the relationship between technical debt and affective states (feelings, emotions, and moods) from software practitioners.MethodForty participants (N = 40) from twelve companies took part in a mixed-methods approach, consisting of a repeated-measures (r = 5) experiment (n = 200), a survey, and semi-structured interviews. From the qualitative data, it is clear that technical debt activates a substantial portion of the emotional spectrum and is psychologically taxing. Further, the practitioners’ reactions to technical debt appear to fall in different levels of maturity.ResultsThe statistical analysis shows that different design smells (strong indicators of technical debt) negatively or positively impact affective states.ConclusionsWe argue that human aspects in technical debt are important factors to consider, as they may result in, e.g., procrastination, apprehension, and burnout.

Exploratory study of the impact of project domain and size category on the detection of the God class design smell

Design smell detection has proven to be an efficient strategy to improve software quality and consequently decrease maintainability expenses. This work explores the influence of the information about project context expressed as project domain and size category information, on the automatic detection of the god class design smell by machine learning techniques. A set of experiments using eight classifiers to detect god classes was conducted on a dataset containing 12, 587 classes from 24 Java projects. The results show that classifiers change their behavior when they are used on datasets that differ in these kinds of project information. The results show that god class design smell detection can be improved by feeding machine learning classifiers with this project context information.

Are Multi-Language Design Smells Fault-Prone? An Empirical Study

Nowadays, modern applications are developed using components written in different programming languages and technologies. The cost benefits of reuse and the advantages of each programming language are two main incentives behind the proliferation of such systems. However, as the number of languages increases, so do the challenges related to the development and maintenance of these systems. In such situations, developers may introduce design smells (i.e., anti-patterns and code smells) which are symptoms of poor design and implementation choices. Design smells are defined as poor design and coding choices that can negatively impact the quality of a software program despite satisfying functional requirements. Studies on mono-language systems suggest that the presence of design smells may indicate a higher risk of future bugs and affects code comprehension, thus making systems harder to maintain. However, the impact of multi-language design smells on software quality such as fault-proneness is yet to be investigated. In this article, we present an approach to detect multi-language design smells in the context of JNI systems. We then investigate the prevalence of those design smells and their impacts on fault-proneness. Specifically, we detect 15 design smells in 98 releases of 9 open-source JNI projects. Our results show that the design smells are prevalent in the selected projects and persist throughout the releases of the systems. We observe that, in the analyzed systems, 33.95% of the files involving communications between Java and C/C++ contain occurrences of multi-language design smells. Some kinds of smells are more prevalent than others, e.g., Unused Parameters , Too Much Scattering , and Unused Method Declaration . Our results suggest that files with multi-language design smells can often be more associated with bugs than files without these smells, and that specific smells are more correlated to fault-proneness than others. From analyzing fault-inducing commit messages, we also extracted activities that are more likely to introduce bugs in smelly files. We believe that our findings are important for practitioners as it can help them prioritize design smells during the maintenance of multi-language systems.

On the practitioners’ understanding of coupling smells — A grey literature based Grounded-Theory study

Code and design smells, such as the coupling smells examined in this article, are widely studied. Existing empirical studies reveal gaps between the scientific theory and practice, not yet explained by the scientific literature. Only basic coupling smell detection approaches and metrics seem to have been transferred to practice so far. This article aims to study the current practitioner’s understanding of coupling smells. Based on grey literature sources containing practitioner views on coupling smells, we performed a Grounded Theory (GT) study. We used UML-based modeling to precisely encode our findings and performed a rigorous analysis of our codes and models. Our results are defining factors of coupling smells, as well as smell impacts, trade-offs, relationships to other smells, relationships to practices and patterns, and fix options as perceived by practitioners. We further identified gaps in the understanding of coupling smells between science and practice, and derived opportunities and challenges for future scientific work. Five lessons are presented as opportunities and challenges for future research. Our results can help scientists to get a better understanding of practitioner concerns, and practitioners to get an overview of the current perception of other practitioners on coupling smells.

Smell in Industrial Design: A Systematic Review

A smell in industrial product design is defined as an awareness of the dimensions in design creation. Theoretical development for the role of smells in design has led to a significant increase in industrial design. However, despite numerous studies on smells within industrial design, a holistic overview through systematic reporting remains unavailable. In this paper, the authors conducted a systematic review of studies on smells in academic articles on industrial design. The review method was adopted from the Reporting Standards for Systematic Evidence Syntheses (ROSES). The academic databases involved are Scopus, Science Direct, Web of Science and Google Scholar. This study discovered that studies on smells in industrial design have researched the following aspects: 1) smells as design attributes; 2) users' perceptions based on smells; and 3) appraisals of smells embedded in products. Practitioners, educators and researchers can use this systematic review to examine the needs of smell-related sensorial concerns in the current product design applications.

Analysing Agreement Among Different Evaluators in God Class and Feature Envy Detection

The automatic detection of Design Smells has evolved in parallel to the evolution of automatic refactoring tools. There was a huge rise in research activity regarding Design Smell detection from 2010 to the present. However, it should be noted that the adoption of Design Smell detection in real software development practice is not comparable to the adoption of automatic refactoring tools. On the basis of the assumption that it is the objectiveness of a refactoring operation as opposed to the subjectivity in definition and identification of Design Smells that makes the difference, in this paper, the lack of agreement between different evaluators when detecting Design Smells is empirically studied. To do so, a series of experiments and studies were designed and conducted to analyse the concordance in Design Smell detection of different persons and tools, including a comparison between them. This work focuses on two well known Design Smells : God Class and Feature Envy . Concordance analysis is based on the Kappa statistic for inter-rater agreement (particularly Kappa-Fleiss ). The results obtained show that there is no agreement in detection in general, and, in those cases where a certain agreement appears, it is considered to be a fair or poor degree of agreement, according to a Kappa-Fleiss interpretation scale. This seems to confirm that there is a subjective component which makes the raters evaluate the presence of Design Smells differently. The study also raises the question of a lack of training and experience regarding Design Smells .

The Technical Debt Density Over Multiple Releases and the Refactoring Story

Do developers postpone fixing Technical Debt (TD) in software systems? TD is a metaphor that refers to short-term decisions in software development that may affect the cost of the software development life cycle. The bad smell is an imperfect solution in the software system that negatively impacts the internal software quality and maintainability. In this paper, we will study five open-source software projects (OSSPs) that have several releases and also estimate the numbers of architecture smells (ASs), design smells (DSs), and code smells (CSs) for every release. Designite will be used to detect smells. We describe a case study conducted to explore the following: (1) What is the average smells density for architecture, design, and code smells in an OSSP? (2) Does the density of each smell type increase over multiple releases? (3) What percentage of each smell-type density is eliminated by refactoring? We collected around 2 million LOC from five OSSPs that have multiple releases from the GitHub repository to statistically analyze the software concerning the smells as indicators of TD. We find 36% of Architecture Technical Debt (ATD) is Cyclic Dependency, while 33% of Design Debt (DD) is Cyclically-dependent Modularization. More than 70% of Code Debt (CD) is Magic Number. Even though the developers do refactoring between releases, the TD density in general increases. On average, by refactoring, developers remove around 48%, 16%, and 22% from the introduced ATD, DD, and CD from their next release, respectively.

An empirical investigation on the relationship between design and architecture smells

Architecture of a software system represents the key design decisions and therefore its quality plays an important role to keep the software maintainable. Code smells are indicators of quality issues in a software system and are classified based on their granularity, scope, and impact. Despite a plethora of existing work on smells, a detailed exploration of architecture smells, their characteristics, and their relationships with smells in other granularities is missing. The paper aims to study architecture smells characteristics, investigate correlation, collocation, and causation relationships between architecture and design smells. We implement smell detection support for seven architecture smells. We mine 3 073 open-source repositories containing more than 118 million lines of C# code and empirically investigate the relationships between seven architecture and 19 design smells. We find that smell density does not depend on repository size. Cumulatively, architecture smells are highly correlated with design smells. Our collocation analysis finds that the majority of design and architecture smell pairs do not exhibit collocation. Finally, our causality analysis reveals that design smells cause architecture smells.