Let’s explore some of the most common code smells that developers encounter and how to address them. Code smells are indicators of potential issues in your codebase, and recognizing them can lead to better software quality. Here are 31 code smells you should be familiar with:
Dispensables
1. Comments
While comments are essential for documenting code, excessive or confusing comments can be problematic. If your code needs extensive comments to explain its logic, consider refactoring it to make it more self-explanatory.
2. Duplicate Code
Duplication is a common issue that leads to maintenance nightmares. Repeated code fragments should be extracted into reusable functions or classes.
3. Lazy Class
Lazy classes serve no purpose and can be safely removed. If a class lacks functionality or remains unused, consider deleting it.
4. Dead Code
Unused code segments clutter your project and confuse other developers. Regularly clean up dead code to keep your codebase lean.
5. Speculative Generality
Avoid overengineering by creating overly generic solutions. Only add abstractions when necessary, not preemptively.
6. Oddball Solution
Sometimes, developers come up with unconventional solutions that deviate from established patterns. While creativity is valuable, ensure that your solution aligns with best practices.
Bloaters
7. Large Class
Monolithic classes violate the Single Responsibility Principle. Split large classes into smaller, focused ones.
8. Long Method
Long methods are hard to read and maintain. Break them down into smaller functions with clear responsibilities.
9. Long Parameter List
Excessive parameters make method calls cumbersome. Consider using data structures (e.g., objects) to group related parameters.
10. Primitive Obsession
Relying too much on primitive data types (e.g., using strings for everything) leads to code smells. Replace them with custom classes when appropriate.
11. Data Clumps
When several data items consistently appear together, consider encapsulating them into a single object.
Abusers
12. Switch Statements
Switch statements violate the Open-Closed Principle. Use polymorphism or other design patterns instead.
13. Temporary Field
Temporary fields are variables set but never used. Remove them to improve code clarity.
14. Refused Bequest
Inheritance hierarchies can lead to unwanted inherited behavior. Avoid inheriting methods or properties that don’t make sense in the subclass.
15. Alternative Classes with Different Interfaces
Similar classes with different interfaces confuse developers. Aim for consistency in naming and functionality.
16. Combinatorial Explosion
When dealing with multiple flags or options, avoid creating an explosion of combinations. Simplify your design.
17. Conditional Complexity
Complex conditional logic makes code hard to follow. Refactor complex conditions into smaller, more readable expressions.
Couplers
18. Inappropriate Intimacy
Classes that are too tightly coupled violate encapsulation. Reduce dependencies between classes.
19. Indecent Exposure
Avoid exposing internal details unnecessarily. Limit access to what’s essential.
20. Feature Envy
When one class excessively uses methods or properties of another, consider moving the logic to the appropriate class.
21. Message Chains
Chains of method calls between objects create tight coupling. Simplify chains to improve maintainability.
22. Middle Man
Remove unnecessary intermediary classes that merely delegate calls to other classes.
Preventers
23. Divergent Change
If a class frequently changes for different reasons, it violates the Single Responsibility Principle. Split it into smaller, focused classes.
24. Shotgun Surgery
When a single change requires modifications across multiple classes, refactor to reduce the impact.
25. Parallel Inheritance Hierarchies
Avoid creating parallel class hierarchies that mirror each other. Simplify your design.
Other Notable Mentions
26. Inconsistent Names
Use consistent naming conventions to improve code readability.
27. Uncommunicative Name
Choose descriptive names for variables, methods, and classes.
28. Type Embedded in Name
Avoid including type information in variable or method names.
29. Magic Numbers
Replace hard-coded numeric values with named constants or enums.
30. Incomplete Library Class
Extend library classes when necessary rather than duplicating their functionality.
31. Inconsistent Formatting
Maintain consistent code formatting throughout your project.
Remember, code smells are hints, not certainties. Use them as a guide to improve your codebase and write cleaner, more maintainable software. Happy coding! 🚀
For more in-depth exploration of code smells, check out the official Detekt documentation.
¹: [Pragmatic Ways – 31 code smells all developers should be familiar with](https://pragmaticways.com/31-code-smells-you-must
Source: Conversation with Bing, 2/15/2024
(1) 31 code smells all developers should be familiar with – Pragmatic Ways. https://pragmaticways.com/31-code-smells-you-must-know/.
(2) Identifying and addressing Kotlin code smells – LogRocket Blog. https://blog.logrocket.com/identifying-addressing-kotlin-code-smells/.
(3) Uncovering the Scent of Code: Understanding and Eliminating Code Smells …. https://medium.com/multinetinventiv/uncovering-the-scent-of-code-understanding-and-eliminating-code-smells-a3e620b1abae.
(4) 5 most common code smells that you should avoid – Medium. https://medium.com/geekculture/5-most-common-code-smells-that-you-should-avoid-86ae41cb1dc7.
(5) What are Code Smells? (Examples with Solutions) | Built In. https://builtin.com/software-engineering-perspectives/code-smells.
Author: John Rowan
I am a Senior Android Engineer and I love everything to do with computers. My specialty is Android programming but I actually love to code in any language specifically learning new things.Share this:
