Exploring Transfer Learning for Multilingual Software Quality: Code Smells, Bugs, and Harmful Code

Background: Code smells are considered detrimental to maintainability. To plan QA preventive initiatives (e.g. refactoring actions) it is important to know if the application domain is likely to affect the incidence of those problems. Objective: The main goal of this paper is to check if the application domain has a statistically significant impact on the incidence of code smells. Methods: We conducted a quasi-experiment using 118 Java applications, classified into 6 application domains, and including 7 types of code smells. To test the formulated hypotheses, we used the Kruskal-Wallis and ANOVA tests. Results: Our results show that the incidence of most code smells does not depend on the application domain, with the exception of Duplicated Code smell, where it was found that its incidence in the domain Home & Education is superior to the others. Limitations: This study was based on medium sized open source applications written in Java. Therefore, its external validity will be questionable outside this scope. Conclusions: For 6 out of 7 code smell types, our results corroborate previous studies where no difference could be found on code smells incidence across applications. However, statistically significant differences were found for the Duplicated Code (aka Clone) smell. This result confirmed the claim produced by Martin Fowler almost 20 years ago that software clones may be induced by the application domain.

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.

The objective of this paper is to study the relationship between different types of object-oriented software metrics, code smells and actual changes in software code that occur during maintenance period. It is hypothesized that code smells are indicators of maintenance problems. To understand the relationship between code smells and maintenance problems, we extract code smells in a Java based mobile application called MOBAC. Four versions of MOBAC are studied. Machine learning techniques are applied to predict software change-proneness with code smells as predictor variables. The results of this paper indicate that codes smells are more accurate predictors of change-proneness than static code metrics for all machine learning methods. However, class imbalance techniques did not outperform class balance machine learning techniques in change-proneness prediction. The results of this paper are based on accuracy measures such as F-measure and area under ROC curve.

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.

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.

The process of refactoring enhances software quality by modifying its design composition while preserving its core framework. However, addressing code smells without appropriate prioritization can be ineffective. Code smells significantly increase maintenance costs and obstruct system evolution. Refactoring sequencing techniques mitigate these issues by improving a system’s internal structure without altering its external behavior. In large-scale systems, the sheer number of code smells can be overwhelming, and not all can be automatically resolved. Hence, prioritizing code smells based on criteria such as risk and importance is essential. This paper introduces a novel hybrid approach utilizing the hybrid spotted hyena and emperor penguin (HSHEP) optimization-based algorithm. This approach aims to optimize the sequence of code smell bugs by incorporating maintainer opinions and requirements, thereby maximizing the resolution of critical code smells. Unlike existing technologies, the HSHEP algorithm combines the strengths of two optimization strategies, offering a unique and innovative solution to refactoring challenges. To validate the effectiveness of the proposed method, it was applied to various large-scale open-source systems, analyzing five different types of code smells. Results demonstrated a significant improvement in maintenance efficiency and system evolution, confirming the superior performance and practical applicability of the HSHEP-based approach. Received: 22 April 2024 | Revised: 13 June 2024 | Accepted: 30 June 2024 Conflicts of Interest The authors declare that they have no conflicts of interest in this work. Data Availability Statement Data sharing is not applicable to this article as no new data were created or analyzed in this study. Author Contribution Statement Ritika Maini: Conceptualization, Methodology, Software, Validation, Formal analysis, Investigation, Resources, Data curation, Writing – original draft, Writing – review & editing, Visualization, Funding acquisition. Navdeep Kaur: Supervision. Amandeep Kaur: Project administration.

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.

Code smells are symptoms of poor design and implementation choices that may hinder code comprehension and possibly increase change- and fault-proneness of source code. Several techniques have been proposed in the literature for detecting code smells. These techniques are generally evaluated by comparing their accuracy on a set of detected candidate code smells against a manually-produced oracle. Unfortunately, such comprehensive sets of annotated code smells are not available in the literature with only few exceptions. In this paper we contribute (i) a dataset of 243 instances of five types of code smells identified from 20 open source software projects, (ii) a systematic procedure for validating code smell datasets, (iii) LANDFILL, a Web-based platform for sharing code smell datasets, and (iv) a set of APIs for programmatically accessing LANDFILL's contents. Anyone can contribute to Landfill by (i) improving existing datasets (e.g., Adding missing instances of code smells, flagging possibly incorrectly classified instances), and (ii) sharing and posting new datasets. Landfill is available at www.sesa.unisa.it/landfill/, while the video demonstrating its features in action is available at http://www.sesa.unisa.it/tools/landfill.jsp.

As one of the most popular dynamic languages, Python experiences a decrease in readability and maintainability when code smells are present. Recent advancements in Large Language Models have sparked growing interest in AI-enabled tools for both code generation and refactoring. GitHub Copilot is one such tool that has gained widespread usage. Copilot Chat, released in September 2023, functions as an interactive tool aimed at facilitating natural language-powered coding. However, limited attention has been given to understanding code smells in Copilot-generated Python code and Copilot Chat's ability to fix the code smells. To this end, we built a dataset comprising 102 code smells in Copilot-generated Python code. Our aim is to first explore the occurrence of code smells in Copilot-generated Python code and then evaluate the effectiveness of Copilot Chat in fixing these code smells employing different prompts. The results show that 8 out of 10 types of code smells can be detected in Copilot-generated Python code, among which Multiply-Nested Container is the most common one. For these code smells, Copilot Chat achieves a highest fixing rate of 87.1%, showing promise in fixing Python code smells generated by Copilot itself. In addition, the effectiveness of Copilot Chat in fixing these smells can be improved by providing more detailed prompts.

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.

As the development of Solidity contracts on Ethereum , more developers are reusing them on other compatible blockchains. However, developers may overlook the differences between the designs of the blockchain system, such as the Gas Mechanism and Consensus Protocol , leading to the same contracts on different blockchains not being able to achieve consistent execution as on Ethereum . This inconsistency reveals design flaws in reused contracts, exposing code smells that hinder code reusability, and we define this inconsistency as EVM-Inequivalent Code Smells . In this paper, we conducted the first empirical study to reveal the causes and characteristics of EVM-Inequivalent Code Smells . To ensure the identified smells reflect real developer concerns, we collected and analyzed 1,379 security audit reports and 326 Stack Overflow posts related to reused contracts on EVM-compatible blockchains, such as Binance Smart Chain (BSC) and Polygon . Using the open card sorting method, we defined six types of EVM-Inequivalent Code Smells . For automated detection, we developed a tool named EquivGuard . It employs static taint analysis to identify key paths from different patterns and uses symbolic execution to verify path reachability. Our analysis of 905,948 contracts across six major blockchains shows that EVM-Inequivalent Code Smells are widespread, with an average prevalence of 17.70%. While contracts with code smells do not necessarily lead to financial loss and attacks, their high prevalence and significant asset management underscore the potential threats of reusing these smelly Ethereum contracts. Thus, developers are advised to abandon Copy-and-Paste programming practices and detect EVM-Inequivalent Code Smells before reusing Ethereum contracts.

Code smells are code structures that indicate a potential issue in code design or implementation. These issues could affect the processes of code testing and maintenance, and overall software quality. Therefore, it is important to detect code smells in the early stages of software development to enhance system quality. Most studies have focused on detecting code smells of a single programming language. This article explores TL for cross-language code smell detection, where Java is the source, and both C# and Python are the target datasets, focusing on Large Class, Long Method, and Long Parameter List code smells. We conducted a comparison study across two transfer learning approaches—instance-based (Importance Weighting Classifier, Nearest Neighbors Weighting, and Transfer AdaBoost) and parameter-based (Transfer Tree, Transfer Forest)—with various base models. The results showed that the instance-based approach outperformed the parameter-based approach, particularly with Transfer AdaBoost using ensemble learning base models. The Transfer AdaBoost approach with Gradient Boosting and Extra Trees achieved consistent and robust results across both C# and Python, with an 83% winning rate, as indicated by the Wilcoxon signed-rank test. These findings underscore the effectiveness of transfer learning for cross-language code smell detection, supporting its generalizability across different programming languages.

WITHDRAWN: Prioritization of code smells in object-oriented software: A review

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.