When and Why Your Code Starts to Smell Bad

@article{Tufano2015WhenAW,
  title={When and Why Your Code Starts to Smell Bad},
  author={Michele Tufano and Fabio Palomba and Gabriele Bavota and Rocco Oliveto and Massimiliano Di Penta and Andrea De Lucia and Denys Poshyvanyk},
  journal={2015 IEEE/ACM 37th IEEE International Conference on Software Engineering},
  year={2015},
  volume={1},
  pages={403-414}
}
In past and recent years, the issues related to managing technical debt received significant attention by researchers from both industry and academia. There are several factors that contribute to technical debt. One of these is represented by code bad smells, i.e., Symptoms of poor design and implementation choices. While the repercussions of smells on code quality have been empirically assessed, there is still only anecdotal evidence on when and why bad smells are introduced. To fill this gap… 
Code smells: relevance of the problem and novel detection techniques
TLDR
There is a lack of evicence regarding (i) the circustamces leading to code smell introduction, (ii) the real impact of code smells on maintainability, since previous studies focused the attention on a limited number of software projects.
A Systematic Literature Review: Code Bad Smells in Java Source Code
TLDR
This SLR identified that code clone (code smell) receives most research attention and a significant correlation between detection techniques and correlation between the detection techniques, in addition to finding the name of the code smells that need more attention in detection approaches.
Understanding Technical Debt at the Code Level from the Perspective of Software Developers
TLDR
This paper presents the results of a survey involving 74 participants that work in the Brazilian software industry, in order to understand why technical debt is introduced, eliminated and how it is managed in practice, with a focus on the code level.
The Impact of Code Smells on Software Bugs: A Systematic Literature Review
TLDR
This study provides an up-to-date and structured understanding of the influence of code smells on the occurrence of software bugs based on findings systematically collected from a list of relevant references in the latest decade.
Analyzing the Relationship between Software Metrics and Bad Smells Using Critical Metric Value (CMV)
TLDR
The concept of Critical Metric Value (CMV) has been introduced in the current study, and its impact on the occurrence of five selected bad smells has been examined to establish a relationship between software metrics and bad smells.
[Journal First] The Scent of a Smell: An Extensive Comparison Between Textual and Structural Smells
TLDR
Results indicate that textually detected code smells are easier to identify and for this reason they are considered easier to refactor with respect to code smells detected using structural properties, which are often perceived as more severe, but more difficult to exactly identify and remove.
An Empirical Study on the Impact of Code Contributor on Code Smell
TLDR
The empirical study indicated that the greater number of contributors involved, the more likely it is to introduce code smell, and having more mature contributors, who participate in more versions, can avoid the introduction of code smell.
The smell of fear: on the relation between test smells and flaky tests
TLDR
The effect of refactoring is evaluated, showing that it is not only able to remove design flaws, but also fixes all 75% flaky tests causally co-occurring with test smells.
House of Cards: Code Smells in Open-Source C# Repositories
TLDR
The results of co-occurrence analysis imply that whenever unutilized abstraction or magic number smells are found, it is very likely to find other smells from the same smell category in the project.
Towards Effective Teams for the Identification of Code Smells
TLDR
An initial set of practical suggestions for composing more effective teams to the identification of code smells are presented, addressed to human aspects, such as the interaction among individuals and their professional roles.
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 110 REFERENCES
When and Why Your Code Starts to Smell Bad (and Whether the Smells Go Away)
TLDR
The findings mostly contradict common wisdom, showing that most of the smell instances are introduced when an artifact is created and not as a result of its evolution, and at the same time, 80 percent of smells survive in the system.
Do They Really Smell Bad? A Study on Developers' Perception of Bad Code Smells
TLDR
This study showed to developers code entities -- belonging to three systems -- affected and not by bad smells, and asked them to indicate whether the code contains a potential design problem, and if any, the nature and severity of the problem.
Do developers care about code smells? An exploratory survey
TLDR
This paper reports on the results obtained from an exploratory survey involving 85 professional software developers, to better understand the knowledge about, and interest in code smells, together with their perceived criticality.
Quantifying the Effect of Code Smells on Maintenance Effort
TLDR
To reduce maintenance effort, a focus on reducing code size and the work practices that limit the number of changes may be more beneficial than refactoring code smells.
Exploring the impact of inter-smell relations on software maintainability: An empirical study
TLDR
It is argued that future studies into the effects of code smells on maintainability should integrate dependency analysis in their process so that they can obtain a more complete understanding by including such coupled interactions.
Investigating the Evolution of Bad Smells in Object-Oriented Code
  • A. Chatzigeorgiou, A. Manakos
  • Computer Science
    2010 Seventh International Conference on the Quality of Information and Communications Technology
  • 2010
TLDR
This paper explores the presence and evolution of non-trivial bad smells by analyzing past versions of code and attempts to study the subject from the point of view of the problems themselves distinguishing deliberate maintenance activities from the removal of design problems as a side effect of software evolution.
An empirical analysis of the distribution of unit test smells and their impact on software maintenance
TLDR
The results show that (i) test smells are widely spread throughout the software systems studied and (ii) most of the test smells have a strong negative impact on the comprehensibility of test suites and production code.
An empirical investigation into the nature of test smells
TLDR
The results show that developers generally do not recognize (potentially harmful) test smells, highlighting that automated tools for identifying such smells are much needed, and that test smells are usually introduced when the corresponding test code is committed in the repository for the first time.
Understanding the longevity of code smells: preliminary results of an explanatory survey
TLDR
The preliminary results of an explanatory survey aimed at better understanding the longevity of code smells in software projects reveal, for instance, that smell removal with refactoring tools is often avoided when maintaining frameworks or product lines.
Do code smells reflect important maintainability aspects?
  • A. Yamashita, L. Moonen
  • Computer Science
    2012 28th IEEE International Conference on Software Maintenance (ICSM)
  • 2012
TLDR
This paper reports on an empirical study that investigates the extent to which code smells reflect factors affecting maintainability that have been identified as important by programmers.
...
1
2
3
4
5
...