Cross-Language Code Smell Detection via Transfer Learning

Background Code smells are an indicator that something is misplaced in software systems, which can reduce maintainability and quality of software applications. In the literature, there is much research about code smells where numerous strategies for automating code smell detection have been developed to improve software quality. Objective The purpose of this work is to provide a review of search‐based, heuristic‐based, machine learning‐based, deep learning‐based, and hybrid‐based code smell detection algorithms. Method Concerning the main goals of this research, we have found 38 primary studies. We gathered relevant studies published on this topic between 2017 and 2024. These articles' data were extracted according to some criteria, including code smells, machine learning methods, programming languages, dataset size, evaluation strategy, and statistical tests. Results Machine learning‐based code smell detection methods have been suggested in most empirical investigations. We found that machine learning and deep learning are the most popular approaches for predicting code smells. Researchers typically employ support vector machine and decision tree algorithms. The Arcelli Fontana and Zanoni benchmark dataset was the most frequently investigated dataset. Most of the research community's attention has been focused on a small number of smells, including blob, feature envy, long method, and data class. Researchers also pay more attention to code smells like Long Method and Feature Envy. Deep learning techniques are increasingly used, and most scientists utilize source code metrics as indicators. The standard performance measurements mostly used are F‐measure, recall, and precision. Conclusions The study provides an overview of existing approaches and highlights current research trends in code smell detection, particularly the increasing use of machine learning and deep learning techniques.

Code smells are indicators of potential problems in software. They tend to have a negative impact on software quality. Several studies use machine learning techniques to detect bad smells. The objective of this study is to systematically review and analyze machine learning techniques used to detect code smells to provide interested research community with knowledge about the adopted techniques and practices for code smells detection. We use a systematic literature review approach to review studies that use machine learning techniques to detect code smells. Seventeen primary studies were identified. We found that 27 code smells were used in the identified studies; God Class and Long Method, Feature Envy, and Data Class are the most frequently detected code smells. In addition, we found that 16 machine learning algorithms were employed to detect code smells with acceptable prediction accuracy. Furthermore, we the results also indicate that support vector machine techniques were investigated the most. Moreover, we observed that J48 and Random Forest algorithms outperform the other algorithms. We also noticed that, in some cases, the use of boosting techniques on the models does not always enhance their performance. More studies are needed to consider the use of ensemble learning techniques, multiclassification, and feature selection technique for code smells detection. Thus, the application of machine learning algorithms to detect code smells in systems is still in its infancy and needs more research to facilitate the employment of machine learning algorithms in detecting code smells.

Code smells are considered symptoms of poor implementation choices, which may hamper the software maintainability. Hence, code smells should be detected as early as possible to avoid software quality degradation. Unfortunately, detecting code smells is not a trivial task. Some preliminary studies investigated and concluded that machine learning (ML) techniques are a promising way to better support smell detection. However, these techniques are hard to be customized to promote an early and accurate detection of specific smell types. Yet, ML techniques usually require numerous code examples to be trained (composing a relevant dataset) in order to achieve satisfactory accuracy. Unfortunately, such a dependency on a large validated dataset is impractical and leads to late detection of code smells. Thus, a prevailing challenge is the early customized detection of code smells taking into account the typical limited training data. In this direction, this paper reports a study in which we collected code smells, from ten active projects, that were actually refactored by developers, differently from studies that rely on code smells inferred by researchers. These smells were used for evaluating the accuracy regarding early detection of code smells by using seven ML techniques. Once we take into account such smells that were considered as important by developers, the ML techniques are able to customize the detection in order to focus on smells observed as relevant in the investigated systems. The results showed that all the analyzed techniques are sensitive to the type of smell and obtained good results for the majority of them, especially JRip and Random Forest. We also observe that the ML techniques did not need a high number of examples to reach their best accuracy results. This finding implies that ML techniques can be successfully used for early detection of smells without depending on the curation of a large dataset.

Developers often combine multiple programming languages to build large-scale applications. They choose programming languages properly for their tasks at hand instead of solving all of their problems with a single language. Foreign Functions Interface allow code written in one programming language to access features available in another programming language. Multi-language systems benefits from several advantages. However, they also introduce challenges related to the development, comprehension, and maintenance of such systems. Software quality is achieved partly by following good practices---architectural styles, design patterns, idioms---and avoiding bad practices---design anti-patterns and code smells. Yet, a review of the literature shows that there are a few works that study developers' practices among multi-language systems. The heterogeneity of components introduces code smells at the source code level. While design patterns are defined as good solutions to a recurrent problem, code smells are defined as poor design and coding choices that can negatively impact the quality of a software program despite satisfying functional requirements. In this paper, we report four patterns and five code smells related to multi-language systems. Those patterns and code smells were extracted from open-source systems, developers' documentation, and bug reports. We encoded these practices in the form of patterns and code smells in the context of Java Native Interface systems.

In the realm of software development, detecting code smells is a critical task for ensuring good code quality. God class code smell specifically has a specific nature associated with a great deal of subjectivity due to the levels of coupling and cohesion associated to it. Automated techniques for code smell detection aim to resolve this subjectivity. Machine learning techniques have shown promising results that tend to improve accuracy and reduce the bias associated with other techniques for God class identification. This is due to their pattern recognition capabilities making them more objective in identifying patterns that indicate code smells. However, current results need to be further improved in terms of both accuracy and generalizability. The challenge in the use of machine learning is not only in selecting the most appropriate technique but also lies in effectively representing source code as input patterns fed to Machine Learning (ML) classifier(s). Code representation plays a pivotal role in encoding source code for ML algorithms. This study aims improving the accuracy and generalizability of God class code smell detection via exploring the effect of using various code representation techniques, namely, tree-based, metric-based, code embedding, and token-based code representation techniques on the ML detection results. The study is conducted on the MLCQ dataset, and applies various ML algorithms (specifically: Logistic Regression, Random Forest, SVM, Decision Tree, Naive Bayes, Gradient Boosting, XGBoost). The evaluation results show how different code representation techniques influence ML detection outcomes and the comparative performance of ML algorithms. The study findings reveal that the F1-score achieved outperforms prior studies on the MLCQ dataset, indicating the effectiveness of the proposed approach. The presented results reveal how the code representation technique used makes a significant impact on the ML classifier results. This paves the way for developing intelligent IDE plugins for just in time God Class code smell detection among other code smells.

Are you smelling it? Investigating how similar developers detect code smells

The quality of source code is negatively impacted by code smells. Since the term "code smell" originated, numerous attempts have been made to comprehend it by identifying it using various techniques, such as metric-based, heuristic-based, optimization-based, machine learning (ML)-based, etc. Among these, supervised machine learning (SML) has shown effectiveness in detecting code smells. However, SML techniques have significant limitations, including the dependency on expensive and high-quality labeled data, the need for representative training datasets, and the risk of introducing biases in labeled examples that lead to skewed predictions. To overcome these challenges, this study introduces a method that leverages unsupervised machine learning (UnML) along with feature engineering. Unlike SML, UnML does not require labeled data and minimizes potential biases. The proposed method was evaluated using four datasets containing different types of code smells and was compared with a previous study that used SML techniques. The results indicate that the UnML-based method is effective, achieving outcomes closely aligned with those from the SML approach. This method is especially beneficial in situations where labeled data is scarce or unavailable and can be used to identify new code smells, generate labeled data for SML and detect multiple code smells simultaneously within a codebase.

The field of software refactoring has been evolving rapidly, driven by the need to maintain software quality and manage complexity as software systems grow. This special issue of the Journal of Software: Evolution and Process focuses on “Software Refactoring: Application Breadth and Technical Depth,” aiming to promote research that advances our understanding of software refactoring practices and their impact. The selected papers in this issue reflect the broad scope and technical depth of the topic, covering a variety of innovative methodologies, empirical studies, and new tools that push the boundaries of current software refactoring research. The paper “Software Refactoring Side Effects” by AbuHassan, Alshayeb, and Ghouti addresses the often-overlooked side effects of software refactoring. The authors propose three different approaches for handling these side effects and employ a multi-objective optimization algorithm to identify optimal refactoring decisions. Their work enhances the understanding of refactoring's unintended consequences and proposes practical solutions, fitting well into the theme of exploring new dimensions of refactoring practices. Zhao et al., in their article “An Architecture Refactoring Approach to Reducing Software Hierarchy Complexity,” introduce a novel metric to quantify software hierarchy complexity and propose the Complexity-oriented Software Architecture Refactoring (CoSSR) approach. Their study demonstrates how reducing software hierarchy complexity can improve software quality, aligning with the issue's focus on reducing complexity through innovative refactoring techniques. The article “MARS: Detecting Brain Class/Method Code Smell Based on Metric-Attention Mechanism and Residual Network” by Zhang and Dong presents a new method for detecting complex code smells using a novel deep learning approach. By leveraging a metric-attention mechanism and an improved residual network, their model shows superior performance compared to existing methods. This research contributes to the special issue by applying cutting-edge machine learning techniques to refactoring challenges. AlOmar et al.'s study, “Behind the Scenes: On the Relationship Between Developer Experience and Refactoring,” investigates the correlation between developer experience and refactoring activities across 800 open-source projects. Their findings highlight that experienced developers tend to perform more varied refactoring operations but document less of their refactoring activities. This study offers a new perspective on how human factors influence refactoring practices, enriching the broader conversation on effective software evolution. In “A Study of Refactorings During Software Change Tasks,” Eilertsen and Murphy explore the reasons behind the disuse of refactoring tools during software change tasks. Their observational study reveals that the strategies developers use significantly impact the use of refactoring tools, pointing to a gap between available tool support and actual developer needs. This paper provides valuable insights into the practical challenges of implementing refactoring in real-world settings. Halepmollasi and Tosun, in “Exploring the Relationship Between Refactoring and Code Debt Indicators,” present an empirical analysis of the association between different types of refactorings, code smells, and faults. Their findings challenge previous assumptions about refactoring's impact on code smells and suggest that refactoring activities might be more fault-inducing than previously thought. This research adds a critical dimension to understanding the effects of refactoring on software quality. Lastly, Abdou and Darwish's article, “Severity Classification of Software Code Smells using Machine Learning Techniques: A Comparative Study,” evaluates various machine learning models for classifying the severity of code smells. Their use of the LIME algorithm for model interpretability provides new insights into predicting code smell severity, contributing to the issue's exploration of data-driven approaches to software maintenance. Recent developments in generative AI and machine learning have opened new avenues for advancing software refactoring practices. As demonstrated by some of the studies in this issue, these technologies can automate and enhance refactoring processes, improve tool support, and provide more accurate code smell detection. The application of AI in this domain is still in its early stages, but it holds great promise for transforming how software systems are maintained and evolved. We encourage researchers to explore these emerging trends further, focusing on integrating AI-driven approaches with traditional software engineering practices. We extend our sincere appreciation to all the authors for their contributions, to the peer reviewers for their invaluable feedback and dedication, and to the editorial board members for their support in assembling this special issue. Together, these efforts have created a diverse collection of research that we believe will significantly impact the field of software refactoring.

Code smells are specific patterns or characteristics in software code that indicate potential design or implementation problems. Identifying code smells has gained significant attention in software engineering. It is essential to address code smells to maintain high-quality software systems. Machine learning (ML) models, such as Long Short-Term Memory (LSTM), have been to detect code smells automatically based on source code features. However, the imbalanced distribution of code smells within software projects poses a challenge to the accuracy of these models. This study explores the role of data balancing methods in optimizing the accuracy of the LSTM model for code smell detection. We investigate different techniques for addressing the class imbalance problem, including random oversampling and synthetic minority oversampling techniques (SMOTE). We evaluate the performance of the LSTM model with and without data balancing methods using accuracy, precision, recall, f-measure, Matthew’s correlation coefficient (MCC), and the area under a receiver operating characteristic curve (AUC). Our experimental results, conducted on four code smell datasets (God class, data class, feature envy, and long method) extracted from 74 open-source systems, demonstrate the effectiveness of data balancing methods in improving the accuracy of the LSTM model for code smell detection. The results indicate that the use of data balancing methods had a positive effect on the predictive accuracy of the LSTM model. In addition, we compared our proposed method with state-of-the-art code smell detection approaches. The findings from the comparison indicate that our proposed method performs notably better than existing state-of the-art approaches across the majority of datasets.

Code smells can be subjectively interpreted, the results provided by detectors are usually different, the agreement in the results is scarce, and a benchmark for the comparison of these results is not yet available. The main approaches used to detect code smells are based on the computation of a set of metrics. However code smell detectors often use different metrics and/or different thresholds, according to their detection rules. As result of this inconsistency the number of detected smells can increase or decrease accordingly, and this makes hard to understand when, for a specific software, a certain characteristic identifies a code smell or not. In this work, we introduce WekaNose, a tool that allows to perform an experiment to study code smell detection through machine learning techniques. The experiment's purpose is to select rules, and/or obtain trained algorithms, that can classify an instance (method or class) as affected or not by a code smell. These rules have the main advantage of being extracted through an example-based approach, rather then a heuristic-based one.

리팩토링은 내부적으로는 시스템의 품질을 개선하고, 외부적으로는 시스템의 기능을 유지하는 일종의 소프트웨어를 변경하는 과정이다. 이러한 리팩토링을 적용하여 기존 소스코드를 개선하기 위해서는 개선할 사항이 무엇인지를 아는 것이 우선이다. 이를 위해 Martin Fowler와 Kent Beck은 코드속의 나쁜 냄새(코드스멜)를 식별할 수 있는 방법을 제시 하였다. 또한 코드스멜을 탐지하고 어디에 어떤 리팩토링을 적용할 것인가를 결정하는 문제와 관련된 몇몇 연구가 발표되었다. 그러나 이러한 연구들은 코드스멜에 대한 명확한 표현이 부족하거나 한정된 코드스멜만을 탐지하는 단점이 있다. 그리고 리팩토링을 적용할 경우 행위보존을 위한 선행조건들의 표현방법이 리팩토링 절차에 포함되어 있거나 정형화되지 않아 행위보존의 모호함이 발생되는 단점을 가지고 있다. 이에 본 논문에서는 OCL을 이용하여 코드스멜의 정보를 정확히 명세화하고, OCL 번역기를 통해 코드스멜을 자동으로 탐지하여 리팩토링하는 프레임워크를 제안한다. 또한 적용사례를 통하여 자바소스코드속의 코드스멜을 OCL로 명세화하여 자동탐지하고, 리팩토링을 적용해 봄으로써 활용성과 효용성을 검증해본다. Refactoring is a kind of software modification process that improves system qualities internally but maintains system functions externally. What should be improved on the existing source codes should take precedence over the others in such a modification process using this refactoring. Martin Fowler and Kent Beck proposed a method that identifies code smells for this purpose. Also, some studies on determining what refactoring will be applied to which targets through detecting code smells in codes were presented. However, these studies have a lot of disadvantages that show a lack of precise description for such code smells and detect limited code smells only. In addition, these studies showed other disadvantages that generate ambiguity in behavior preservation due to the fact that a description method of pre-conditions for the behavior preservation is included in a refactoring process or unformalized. Thus, our study represents a precise specification of code smells using OCL and proposes a framework that performs a refactoring process through the automatic detection of code smells using an OCL interpreter. Furthermore, we perform the automatic detection in which the code smells are be specified by using OCL to the java program and verify its applicability and effectivity through applying a refactoring process.

Software refactoring is an effective method for improvement of software quality while software external behavior remains unchanged. To facilitate software refactoring, a number of tools have been proposed for code smell detection and/or for automatic or semi-automatic refactoring. However, these tools are passive and human driven, thus making software refactoring dependent on developers' spontaneity. As a result, software engineers with little experience in software refactoring might miss a number of potential refactorings or may conduct refactorings later than expected. Few refactorings might result in poor software quality, and delayed refactorings may incur higher refactoring cost. To this end, we propose a monitor-based instant refactoring framework to drive inexperienced software engineers to conduct more refactorings promptly. Changes in the source code are instantly analyzed by a monitor running in the background. If these changes have the potential to introduce code smells, i.e., signs of potential problems in the code that might require refactorings, the monitor invokes corresponding smell detection tools and warns developers to resolve detected smells promptly. Feedback from developers, i.e., whether detected smells have been acknowledged and resolved, is consequently used to optimize smell detection algorithms. The proposed framework has been implemented, evaluated, and compared with the traditional human-driven refactoring tools. Evaluation results suggest that the proposed framework could drive inexperienced engineers to resolve more code smells (by an increase of 140 percent) promptly. The average lifespan of resolved smells was reduced by 92 percent. Results also suggest that the proposed framework could help developers to avoid similar code smells through timely warnings at the early stages of software development, thus reducing the total number of code smells by 51 percent.

Improving and comparing performance of machine learning classifiers optimized by swarm intelligent algorithms for code smell detection

The concept of code smells is widespread in Software Engineering. Despite the empirical studies addressing the topic, the set of context-dependent issues that impacts the human perception of what is a code smell has not been studied in depth. We call this the code smell conceptualization problem. To discuss the problem, empirical studies are necessary. In this work, we focused on conceptualization of god class. God class is a code smell characterized by classes that tend to centralize the intelligence of the system. It is one of the most studied smells in software engineering literature. A controlled experiment that extends and builds upon a previous empirical study about how humans detect god classes, their decision drivers, and agreement rate. Our study delves into research questions of the previous study, adding visualization to the smell detection process, and analyzing strategies of detection. Our findings show that agreement among participants is low, which corroborates previous studies. We show that this is mainly related to agreeing on what a god class is and which thresholds should be adopted, and not related to comprehension of the programs. The use of visualization did not improve the agreement among the participants. However, it did affect the choice of detection drivers. This study contributes to expand empirical evidences on the impact of human perception on detecting code smells. It shows that studies about the human role in smell detection are relevant and they should consider the conceptualization problem of code smells.

Code smells are usually associated with poor coding practices, design issues, and potential bugs.Studies on code smells are important.However, existing studies lack research on the distribution and evolution of code smells in different programming languages.To fill this gap, we collected 9 Java projects and 9 Python projects from GitHub and analyzed them with existing tools.We found that Java's code smell rate (the percentage of the number of code smells in total lines of code) of 11.11% is higher than Python's code smell rate of 1.31%."Magic Number", "Long Statement", and "Unutilized Abstraction" are the top three code smells in Java, while "Design Smells", "Common Weakness Enumeration", and "Unused Code" are the top three code smells in Python.The code smell aggregation level (the percentage of code smells in the top five modules in the total number of code smells) in Java is 44.07%while in Python is 59.18%, indicating that both languages are likely to accumulate code smells in certain modules.During the project's progress, the code smell rate remained steady in both languages, while the aggregation level showed a downward trend.Our findings can help developers understand common code smells and their trends in projects, thus guiding them to improve software quality.