A consequence of the rush in software development is that there are often suboptimal design decisions that, in some aspects, deviate from best practice in software development. In the software development community, there is a general belief that such suboptimal design decisions, which can be identified in source code as code smells, negatively impact software quality, e.g. the rate of identified bugs in post-release software. Consequently, the presence of code smells in a software project could be a predictor of upcoming issues related to low quality software. The methods and approaches applied to control and eventually remedy source code affected by code smells, constitute an important research field in software engineering. The literature review presented in this paper aims to answer the question of whether the correlation between the presence of code smells in source code and a higher incidence of defects in software has been sufficiently analyzed in previous studies. The goal of the literature review is also to determine, which defined code smells were analyzed in studies and where the impact of studied code smells on low quality was confirmed. Furthermore, with the literature review we want to find out how effective the refactoring of smelly classes from the perspective of quality of software can be.
Tough time-to-market constraints and unanticipated integration or evolution issues lead to
design tradeoffs that usually cause flaws in the structure of a software system [
From a broader perspective, schedule pressure has not been identified as the only cause of
code smells in the source code of software systems. Besides tight time constraints, design
flaws can also be produced by carelessness, lack of education, poor processes, lack of
verifications or, even, basic incompetence [
High software quality is evidently a required attribute for successful software pro
If not remedied during a code review, code smells can also be removed in later phases of a
software development cycle. For instance, if a code smell is detected during development, the
developer can easily refactor the detected code smell. The described scenario is especially the
case when low quality program code has been traded for faster development. In practice, it
turns out that if not automated, the source code quality assurance process can be time
consuming, error prone, and costly [
In this paper, we focus our attention on the relationship between the introduction of code smells in source code and the low quality of software products. The goal of this study is to determine whether all types of code smells in a project have an equal impact on software quality or if there is a subset of code smells, which are proven by studies to be particularly harmful for a software project or could even jeopardize a software system in the future. Refactoring is also one of the points of interest in this study. Refactoring detected code smells in source code comes with additional work, which consequently results in higher costs for software development. Refactoring can therefore be expensive, in particular if it is used to remedy code smells that have little, or even zero, impact on low software quality. Code smells must be removed, but only if they represent real quality problems [Fontana, Ferme, Zanoni, and Roveda 2015]. To answer our research goal, we performed a literature review.
This paper is structured as follows. The introduction establishes the scope and purpose of the paper and gives the necessary background information relevant to the research. Following the introduction, a second section explains the procedure of the literature review. We then describe the analysis of studies selected in the process of the literature review. Section 5 outlines the key findings of our research. Finally, in the conclusion, we summarize our research and give concluding remarks.
Code quality has always been an interesting topic of discussion within the programming
community. It is the general belief that good code is the kind of code that can be easily reused
years after it has been written. Such code can be easily taken over and extended by other
programmers. On the other hand, it is believed that low quality code is meant to solve a
problem that exists at the time of its writing and completely ignores any long-term
consequences. Some authors link technical debt caused by the low quality of programming
code with severe maintenance difficulties or even project cancellations [
Despite the fact that these beliefs are deeply rooted and commonly accepted in the software engineering community, there is very little known about formal methods that can be applied to measure tangible effects of poor design decisions on software quality. Similarly, for the development process, a precise prediction of the influence of refactoring activities on software quality can be equally crucial. Without formal approaches to evaluate the benefits of refactor activities, it is hard to justify that these activities are economically viable and worth the resources invested. To dissolve this ambiguity, we performed a literature review, whose main objective is to find studies that analyze the relationship between code smells in source code and the quality of software systems. In our study, we were particularly interested in studies that analyze the impact of code smells on the rate of detected defects in a software product. To the best of our knowledge, this research goal, in that iteration, has so far remained unaddressed.
Based on our research goals, the following four research questions were formed: RQ1: do all of the code smells equally impact software quality in terms of detected software defects? RQ2: which code smells are directly correlated with low software quality in terms of detected software defects? RQ3: does refactoring detected code smells in the source code directly improve software quality measured by defect rate? RQ4: how active is the current research field of studies investigating the influence of code smells on software quality in terms of detected software defects?
In accordance with our research questions, the search was conducted in digital libraries.
According to the research questions, we formed the following search string: ("bad smell*" OR
"code smell*" OR "design flaw*" OR “antipattern*”) AND ("error probability" OR "defects" OR
"bugs" OR "anomalies"). With it, the search was conducted in two digital libraries, Web of
Science and IEEE Xplore. The number of search results and number of selected studies can
be found in Table I. In our research we only included studies available in the selected digital
libraries, which were written in the English language. The search was conducted for both
journal and conference articles. All the studies used in our research were published in the
domain of software engineering.
The research field that addresses quality issues related to code-based technical debt is
relatively broad. In general, four different approaches can be found to software quality
management based on an analysis of structural issues of source code - code smells, automatic
static analysis, grime buildups, and modularity violations [
For each study, we specified a research method used in the study and a publication type of the study. In the majority of studies, an experiment was used as a research method. A case study was used as a research method in only two selected studies. The selected studies were published in both journal and conference proceedings. Although all of the selected research study software was based on the Java platform, this was not a condition for inclusion into our study. Table II shows the number of code smell types analyzed for each study and the software from which the observed code smells were extracted.
In this literature review, we were especially interested in studies that research a direct,
tangible and measurable impact of code smells in source code on an occurrence of quality
issues in software products under the study. According to some authors [
In order to analyze the impact of code smells on software quality in terms of detected bugs, all authors except one rely on freely available source code from open source projects. Open source projects are suitable for these kinds of studies especially because all data related to a development process of software products are freely available online and can be easily obtained by researchers. On the other hand, studying open source software solutions has an advantage from the perspective of the relevance of the derived conclusions. Because open source solutions are built for use in real business environments, the study of them can give us quite relevant study results.
In the case of a study performed
Impact of Code Smells on the Rate of Defects in Software: A Literature Review • 3:5 manually. In studies that used manual data extraction directly from the source code of open sources projects, up to six open source soulutions were analyzed in a study.
To extract information about the defects detected in the studied software solutions, the
researchers relied on issue tracking systems, used by the developers of studied software
solutions to track detected defects in software components. In the case of research performed
by Olbrich, Cruzes, an
To prove the impact of code smell occurrence in source code to a higher rate of detected
bugs in software, source-code studies identified two to nine different types of code smells. The
majority of observed code smells were either defined in Refactoring: Improving the Design of
Existing Code [
Despite the fact that code smell catalogs define a larger set of code smells, for example
[
X X X X X X X X X
X X X X X
X X X X X X
X X X X
X X
X X X X X X X X
The main point of interest of our literature review is to answer the question of whether the presence of code smells in the code base impacts software quality. We are also interested in the impact of code smell removal on software quality. To answer our research goals, we had to analyse studies selected in the previous stage of the study. Despite the fact that approaches to address this research question were quite similar, the results of the studies are not so conclusive and unambiguous.
The first study we analysed was conducted by
Researchers D’Ambros, Bacchelli, and Lanza study an impact of code smells Brain Method, Shotgun Surgery, Feature Envy, Intensive Coupling, and Dispersed Coupling on the occurrence of defects identified in software solutions containing mentioned code smells. The impact of code smells on the low quality of software was studied on six open-source software tools. The results of the study showed that program code, which contains design flaws, do correlate with a higher rate of software defects, but research was unable to correlate a specific code smell type with a higher rate of software defects across all software systems under the study.
Furthermore, a stu
Next, the correlation between code smells and their impact on the frequency of detected
bugs in released software were investigated by R. Marinecu and C. Marinecu in their study
published in 2011. In the study, the authors analysed types of code smells, namely, Data
Class, God Class, Brain Class, and Feature Envy. Influence of code smells on the
defectproneness of software was observed in three versions of Eclipse IDE (versions 2.0, 2.1, and
3.0). The analysis did not confirm any correlation between the observed code smells and an
increased likelihood of exhibiting software defects compared to classes that do not reveal
design flaws. However, a direct correlation between specific code smell types and defect rates
in studied software was not confirmed; instead, the study came to an interesting conclusion.
The study showed that when code smell affected classes are used by their clients, the
likelihood for the clients to exhibit software defects greatly increases, especially in the case of
post-release defects. The research therefore provided an explanation as to why the presence
of code smells in source code do statistically correlate with a higher defect rate in software
despite the fact that classes affected by code smells cannot be strongly related to software
defects. The author of the research came to similar conclusions in one of the following studies
[R.
The same research problem was addressed by Zazworka et al. in a study conducted in 2014. The authors address the impact of structural flaws in the program solution on software quality. They studied four different approaches to structural flaw detection, namely: modularity violations, design patterns and grime buildups, code smells, and automatic static analysis. In the study, they observed if there was a correlation between detected structural
Impact of Code Smells on the Rate of Defects in Software: A Literature Review • 3:7 design flaws and the software defect rate. For the purpose of the case study, the authors considered 13 releases of Hadoop software. In the research, the authors observed 10 different types of code smells, namely: God Class, Brain Class, Refused Parent Bequest, Tradition Breaker, Feature Envy, Data Class, Brain Method, Intensive Coupling, Dispersed Coupling, and Shotgun Surgery. Of all the observed code smell types, only classes affected by Dispersed coupling and God Classes were correlated with higher defect-proneness in the context of the source code of the Hadoop library.
Finally, a study performed
A literature review shows that previous studies analysed the variety of different code
smell types, but that they were rarely able to confirm a positive correlation between classes
containing code smells and a higher rate of software defects in these classes. Furthermore, a
Code smells
literature review shows that there is not a clear pattern in results, which can correlate with a
specific type of code smell with the defect-proneness of a system. Additionally, the results of
some studies (e.g. Olbrich, Cruzes, an
The literature review of selected studies allowed us to answer our research questions. In the
context of RQ1, our results showed that researchers analyzed, for the purpose of the studies,
a variety of code smells, which can be found in the literature. Most of the used code smells
were defined in [
None of the analyzed studies debated the choice of the code smells. It presumably depended on the researcher’s predictions of which code smells could lower software quality. Nevertheless, some code smells occur in experiments and case studies more often than others. Our study shows that Feature Envy was expected to be correlated with a low quality of software in most studies. These types of code smells were included in five out of the six analyzed studies. The code smells God Class and Shotgun Surgery occurred in four of the analyzed studies. Brain class and Data Class could be found in three of the analyzed studies. In all of the studies included in our literature review, researchers analyzed 21 different code smells. The use of code smells in research by various authors is summarized in Table III. Therefore, from the analyzed studies it is evident that all code smells do not affect software quality equally.
After a literature review, we are able to provide an answer to RQ2. The summarized view on the collected data is shown in Table IV. The collected data of our analysis indicate a weak correlation between code smells in the source code and an increased incidence of defects in the studied software. In the analyzed studies, the impact on software defects was confirmed for only a few code smells. Additionally, the correlations that were confirmed are quite contradictory when considering all the analyzed studies that address this research question. For example, a positive correlation between God Class and the high rate of detected defects in studied software was identified in two studies. In one study, the authors did not confirm the studied correlation, and in one study the correlation between God Class and defect rate in software was positive, which means that code smells of that type are likely beneficial for software systems from the perspective of studied aspects of software quality. For other types of code smell, the results of the literature review are even more inconclusive. In answer to RQ2, we have to agree with the authors who claimed that none of the analyzed code smell classes could be undoubtedly correlated with an increased incidence of defects in studied software by itself.
According to the analyzed studies, an answer to the RQ3 about the meaningfulness of refactoring of systems affected by code smells is not straightforward. Despite the fact that the studies show that the presence of an individual code smell in source code classes does not predict a higher defect rate in these classes, the increased existence of code smells in the source code of a software system can predict a higher rate of software defects in a software system.
Impact of Code Smells on the Rate of Defects in Software: A Literature Review • 3:9
According to some of the analyzed studies, when classes that are affected by code smells are
used by client classes in a software system, a higher incidence of software defects is detected
for these client classes. In other words, classes containing code smells are not the source of
defects by themselves. Rather, these smelly classes could be related to low quality issues for
client classes in a software system, which use classes affected by code smells. In addition to
the study by [
On the other han
With regard to RQ4, our analysis of selected studies showed that studies interested in the correlation between code smells and software defects were conducted in the years between 2006 and 2014. Later research in this field was not found despite the fact that many research questions remain open.
This paper presents the results of a literature review in which we addressed the impact of code smells in source code on software quality and the effectiveness of related refactoring activities. In the software development community, it is commonly believed that code smell in the source code can be correlated with low software quality. For instance, the existence of code smells in the source code can be manifested in the post-release era of software products as an increased rate of identified defects. As extracted from the literature, the correlation between code smell classes and the occurrence of defects in software in these classes is weaker than first assumed. Our findings also show that none of the code smells that were analyzed in the studied literature can be explicitly linked to a higher defect-proneness for these classes. Therefore, classes containing code smells are not a distinct carrier of defects in software systems. The latter has a strong impact on refactoring activities, which cannot be pointed only towards classes affected by code smells.
Despite this, some studies detected an increased occurrence of software defects in pieces of software with an increased incidence of code smells in general, which links code smells with low quality software. For future research, an unanswered research question remains: how exactly do code smells help increase the incidence of defects in other classes in a system, and more importantly, how the negative impacts on quality can be neutralized.