Definitions of a Smell

Many authors have defined smells from their perspective. This page attempts to provide a consolidated list of such definitions.

• Smells are certain structures in the code that suggest (sometimes they scream for) the possibility of refactoring. [1]
• Code smells are a metaphor to describe patterns that are generally associated with bad design and bad programming practices. [2]
• Code smells are indicators or symptoms of the possible presence of design smells. [3]
• Code smells are implementation structures that negatively affect system lifecycle properties, such as understandability, testability, extensibility, and reusability; that is, code smells ultimately result in maintainability problems. [4]
• A "bad smell" describes a situation where there are hints that suggest there can be a design problem. [5]
• We define design defects as solutions to recurring problems that generate negative consequences on the quality of object-oriented systems. [6]
• Antipatterns are "poor" solutions to recurring implementation and design problems that impede the maintenance and evolution of programs. [7]
• Anti-patterns are bad solutions to recurring design problems. [8]
• An anti-pattern is a commonly occurring solution to a recurring problem that will typically negatively impact code quality. Code smells are considered to be symptoms of anti-patterns and occur at source code level. [9]
• Antipatterns are defined as patterns that appear obvious but are ineffective or far from optimal in practice, representing worst practices about how to structure and design an ontology. [10]
• Anti-patterns are “poor” solutions to recurring design and implementation problems. [11]
• Developers often introduce bad solutions, anti-patterns, to recurring design problems in their systems and these anti-patterns lead to negative effects on code quality. [12]
• Linguistic Antipatterns (LAs) in software systems are recurring poor practices in the naming, documentation, and choice of identifiers in the implementation of an entity, thus possibly impairing program understanding. [13]
• Design smells are structures in the design that indicate violation of fundamental design principles and negatively impact design quality. [14]
• Code smells are indicators of deeper design problems that may cause difficulties in the evolution of a software system. [15]
• Performance Antipatterns define bad practices that induce performance problems, and their solutions. [16]
• Similarly, Antipatterns are typically a commonly used set of design and coding constructs which might appear intuitive initially, but eventually may be detrimental to one or more aspects of the system. [17]
• Bad design practices at the code level are known as bad smells in the literature. [18]
• Code smells - microstructures in the program - have been used to reveal surface indications of a design problem. [19]
• Configuration smells are the characteristics of a configuration program or script that violate the recommended best practices and potentially affect the program’s quality in a negative way. [20]

References

1. M. Fowler, “Refactoring: Improving the Design of Existing Code”. Addison-Wesley, 1999.
2. AE. van Emden and L. Moonen, "Assuring software quality by code smell detection," 2012 19th Working Conference on Reverse Engineering, Kingston, ON, 2012.
3. Moha, N., & Guéhéneuc, Y.-G. (2007). Decor: a tool for the detection of design defects (pp. 527–528). Presented at the ASE '07: Proceedings of the twenty-second IEEE/ACM international conference on Automated software engineering, New York, USA: ACM.
4. J. Garcia, D. Popescu, G. Edwards, N. Medvidovic, “Toward a Catalogue of Architectural Bad Smells”. QoSA 2009, pp. 146-162.
5. Pérez, J., & Crespo, Y. (2009). Perspectives on automated correction of bad smells (pp. 99–108). Presented at the the joint international and annual ERCIM workshops, New York, New York, USA: ACM Press.
6. Moha, N., Guéhéneuc, Y.-G., Duchien, L., & Le Meur, A.-F. (2010). DECOR: A Method for the Specification and Detection of Code and Design Smells. IEEE Transactions of Software Eng., 36(1), 20–36.
7. Khomh, F., Vaucher, S., Guéhéneuc, Y.-G., & Sahraoui, H. (2011). BDTEX: A GQM-based Bayesian approach for the detection of antipatterns. Journal of Systems and Software (Vol. 84, pp. 559–572)
8. Fourati, R., Bouassida, N., & Abdallah, H. B. (2011). A Metric-Based Approach for Anti-pattern Detection in UML Designs. In Computer and Information Science 2011 (Vol. 364, pp. 17–33). Berlin, Heidelberg: Springer Berlin Heidelberg.
9. Peters, R., & Zaidman, A. (2012). Evaluating the Lifespan of Code Smells using Software Repository Mining (pp. 411–416). Presented at the 2012 16th European Conference on Software Maintenance and Reengineering (CSMR), IEEE.
10. Roussey, C., Corcho, O., Svab-Zamazal, O., Scharffe, F., & Bernard, S. (2012). SPARQL-DL queries for antipattern detection (Vol. 929, pp. 85–96). Presented at the WOP'12: Proceedings of the 3rd International Conference on Ontology Patterns - Volume 929, CEUR-WS.org.
11. Maiga, A., Ali, N., Bhattacharya, N., Sabané, A., Guéhéneuc, Y.-G., Antoniol, G., & Aïmeur, E. (2012). Support vector machines for anti-pattern detection (pp. 278–281). Presented at the ASE 2012: Proceedings of the 27th IEEE/ACM International Conference on Automated Software Engineering, New York, New York, USA: ACM.
12. Jaafar, F., Guéhéneuc, Y.-G., Hamel, S., & Khomh, F. (2013). Mining the relationship between anti-patterns dependencies and fault-proneness (pp. 351–360). Presented at the Proceedings - Working Conference on Reverse Engineering, WCRE, IEEE.
13. Arnaoudova, V., Di Penta, M., Antoniol, G., & Guéhéneuc, Y.-G. (2013). A New Family of Software Anti-patterns: Linguistic Anti-patterns (pp. 187–196). Presented at the CSMR '13: Proceedings of the 2013 17th European Conference on Software Maintenance and Reengineering, IEEE Computer Society.
14. G. Suryanarayana, G. Samarthyam, T. Sharma, “Refactoring for Software Design Smells: Managing Technical Debt”. Morgan Kaufmann, 2014.
15. Yamashita, A. (2014). Assessing the capability of code smells to explain maintenance problems: an empirical study combining quantitative and qualitative data. Empirical Software Engineering, 19(4), 1111–1143.
16. Cortellessa, V., Di Marco, A., & Trubiani, C. (2014). An approach for modeling and detecting software performance antipatterns based on first-order logics. Software and Systems Modeling (SoSyM), 13(1), 391–432.
17. Sharma, V. S., & Anwer, S. (2014). Performance antipatterns: Detection and evaluation of their effects in the cloud (pp. 758–765). Presented at the Proceedings - 2014 IEEE International Conference on Services Computing, SCC 2014, IEEE.
18. Khan, Y. A., & El-Attar, M. (2016). Using model transformation to refactor use case models based on antipatterns. Information Systems Frontiers, 18(1), 171–204.
19. da Silva Sousa, L. (2016). Spotting design problems with smell agglomerations (pp. 863–866). Presented at the ICSE '16: Proceedings of the 38th International Conference on Software Engineering Companion, New York, New York, USA: ACM.
20. T. Sharma, M. Fragkoulis, D. Spinellis, “Does Your Configuration Code Smell?”. MSR 2016, pp. 189–200.