Price sticky
A graphic design representing code smells

Everything You Need To Know About Code Smells

Everything you need to know about Code Smells

Now you can learn everything about code smells in an audio version.

Give it try!


The creator of extreme programming, Kent Beck mentioned the emphasis of design quality while developing software in the late 1990s and popularised the use of the term Code Smells. This term became a commonly used word in programming after it was featured in the book Refactoring: Improving the Design of Existing Code by Martin Fowler, a renowned software scientist who popularised the practice of code refactoring.


Code smells are not bugs or errors. Instead, these are absolute violations of the fundamentals of developing software that decrease the quality of code.


Programming came slowly into the scene of technical development in the mid-1980s with the C programming language on every system. Then coding was considered as a job of creating outputs, whatever the code or way it would be. But we have come a long way since then. Coding is not just about getting outputs but optimizing your whole program so that it performs better, longer, and more evident.

A graphic design representing code smells

Any fool can write code that a computer can understand, good programmers write code that every human can understand. - Martin Fowler Click To Tweet

Having code smells does not certainly mean that the software won’t work, it would still give an output, but it may slow down processing, increased risk of failure and errors while making the program vulnerable to bugs in the future. Smelly code contributes to poor code quality and hence increasing the technical debt.


Code smells indicate a deeper problem, but as the name suggests, they are sniffable or quick to spot. The best smell is something easy to find but will lead to an interesting problem, like classes with data and no behavior. Code smells can be easily detected with the help of tools.

Codegrip makes detecting and managing code smells effortless


Code smell differs from project to project and developer to developer, according to the design standards that have been set by an organization. For higher code quality, we have jotted down common types of smells as a cheat sheet so you can identify and classify them easily.

Sheldon Cooper removing code smells


Application Level Smells

Duplicate CodeSimilar code in more than one location
Shotgun SurgeryOne change requires altering many different classes
Contrived ComplexityUsing complex design patterns where a simpler uncomplicated design could be used.


Meme explaining what feature envy class is


Class Level Smells

Large ClassClass trying to do too much and has too many instance variables
FreeloaderClass doing too little
Feature EnvyClass with a method that seems more interested in other class than the one it is in
Divergent CodeA class that suffers many kinds of changes to bring a change in a system
Data ClumpBunches of data that clump together in lots of places
Inappropriate IntimacyA class that has dependencies on implementation details of other class
Middle ManClass with lots of methods delegated to other class
DowncastingTypecast that breaks the abstraction model
Parallel Inheritance HierarchyEvery time you make a subclass for a single class, you are needed to make subclass for others
Refused BequestSubclass not using methods and data of superclass
Cyclomatic ComplexityClass with too many branches and loops


A meme about when a class borrows a method but doesnt return it.


Method Level Smells

Long MethodLong procedures that are hard to understand
Speculative GeneralityMethods whose only users are test cases
Message ChainsMethod calling a different method which calls a different method which calls a different method… and on and on
Too Many ParametersA very long list of parameters
Oddball SolutionsWhen multiple methods are used to solve the same problem in one program creating inconsistency
God LineAn excessively long line of code
Excessive ReturnerA method that returns more data than what its caller needs
Identifier SizeThe identifier is excessively short or long


Meme telling coders to get to cleaning smelly code


How to get rid of code smell?

Once all types of smells are known, the process of code review begins. Two or more developers may use the primary method, the ad-hoc code review process to try and identify such smells manually. Many smells are not possible to be found by manual reviewing and automated code review tools are used for identifying such bad smells.


Code smells knowing or unknowingly are introduced in the source code, and may also form if you are solving other smells. Developers discard most of the smells consciously because they seem to have a marginalized effect or are just too hard to explain.


When developers find a smelly code, the next step they do is refactoring. Refactoring is the process of changing a software system in such a way that it does not alter the external behavior of the software yet improves its internal structure. It may be the single most important technical factor in achieving agility.


The goal is to stay within reasonable operating limits with limited continual damage. By staying within these limits, you keep costs low, because costs relate nonlinearly to the amount of repair necessary. Refactoring is a process in which the code is divided into smaller sections according to the identified smells.


A decision is then made to either remove them or replace them with a better series of code that may increase code quality and enhance some nonfunctional quality – simplicity, flexibility, understandability, performance. After refactoring, run tests to ensure things still work correctly. Sometimes this process has to be repeated until the smell is gone.


Meme about when coders add more code smell while removing some.


Using automated Code Review tools to remove code smells

Identifying and removing code smells, as seen above, is a tiresome and indefinite process with no particular result if the software would be smell free or not. Also, as it’s near impossible to find and remove all smells manually, using automated code review tools that can identify smells becomes a necessity. Many code review tools help in such operations, but most of them are either dedicated to one programming language or are not decisive enough. CodeGrip is one such tool that is focused on improving code quality, having a feature to identify and display code smells within minutes.


CodeGrip analyses your repositories from Github, BitBucket, and other platforms and displays the number of code Smells under the maintainability tab also displaying technical debt to remove these smells. CodeGrip’s state of the art, suggestive engine helps you classify and resolve code smells easy and individually one at a time. It also organizes each code smell based on severity and time to resolve, so that developers can schedule and solve these issues easily while suggesting a solution as well. CodeGrip makes removing code smells easier than ever, increasing efficiency and decreasing workload.


Sign Up now to find out code smells in your projects for Free!


Code smells can be present even in code written by experienced programmers. It can reduce the lifetime of the software and make it difficult to maintain. Expanding the software functionalities also gets difficult when smelly codes are present. Code smells can go undetected a lot of times. That is why we suggest the use of automated code review tools to make it easier for you to detect code smells.

Liked what you read? Subscribe and get fresh updates.


    P.S. Don’t forget to share this post.

    Post a Comment