The document discusses 10 code anti-patterns that developers should avoid in software development. These anti-patterns include: 1) The Golden Hammer where the same solution is used for different problems, 2) Spaghetti Code which is messy and unorganized, 3) Reinventing the Wheel by creating custom solutions instead of using existing libraries, 4) Dependency Hell which occurs when too many third-party libraries are imported, 5) God Classes that have too many responsibilities, 6) Hard Coding values instead of externalizing them, 7) Boat Anchor code that is written but not needed, 8) Lava Flow legacy code that is risky to change, 9) Copy-Paste Programming without reviewing code, and 10) Cargo Cult Programming

1. 10 Code Anti-Patterns to Avoid in Software
Development
By: Ahmed Salama

2. Intro
The general performance, maintenance, and scalability of an application or system depend highly on the code
structure. Unfortunately, due to the complex nature of software development, developers working on an application
might resolve to use anti-patterns as a quick solution to a problem. Unfortunately, most of these anti-patterns end up
causing problems to the general functionality of an application and future code maintenance.
Here are 10 code anti-patterns you should avoid in software development:
1. The Golden Hammer
2. Spaghetti Code
3. Reinventing the Wheel
4. Dependency Hell
5. God Object or God Class
6. Hard Coding
7. Boat Anchor
8. Lava Flow
9. Copy – Paste Programming
10. Cargo – Cult Programming

3. Intro
● In other words, anti-patterns might look like a good solution at first but eventually turn out to
be the opposite, doing more harm than good.
● Anti-patterns have a negative impact on your software. They either introduce more bugs,
raise security issues, or hinder code readability and maintenance. Below are ten code
anti-patterns that will help you improve how you write your code.

4. 1- The Golden Hammer
● This anti-pattern is a well-known solution in software development and is commonly used to
make the development process much faster. It refers to the concept of using the same
solution used to solve problem “A” to solve problem “B.”
● In software development, every problem has a unique solution. Always remember to
choose the right tools, libraries, frameworks, and architecture for every problem. It is always
recommended to come up with at least two solutions for each problem. Weigh the pros and
cons of each before deciding to implement one that you find suitable.

5. 2- Spaghetti Code
● Have you ever looked at a plate of spaghetti and just observed how each spaghetti is
tangled and jumbled with each other? You can’t even know the start or the end of every
spaghetti. Well, in software development, it is not a surprise to come across code similar to
that.
● Most applications today are a victim of this. It mainly arises when a developer starts working
on a project before taking note of the program flow and understanding the documentation
well.
● Things become worse as your program grows. Your already messy code becomes messier.
You start having multiple functions in different files invoking each other. You start copying and
pasting a piece of already working code to solve a problem in a different part of your
application. Whenever you delete a single function, half of the application breaks.

6. 3- Reinventing the Wheel
● A scenario where developers opt to come up with a custom solution instead of using the
existing solution in the market with the help of API and libraries.
● Think of a company that wants to add a blog/posts page on its website. It will take time and
resources if developers decide to develop a custom CMS (Content Management System)
from scratch. Instead, they can opt for already existing solutions such as WordPress, Joomla,
and even headless CMS like Strapi, Ghost, or Contentful.

7. 4- Dependency Hell
● In most cases, when you focus much on avoiding “Reinventing the Wheel,” you will most
likely fall into the “dependency hell.” Instead of developers developing custom solutions, they
import many third-party libraries into their projects. Unfortunately, some of these libraries
also rely on other external libraries.
●

8. 5- God Object or God Class
● This anti-pattern goes against the Principle of Single Responsibility in programming.
According to this principle, every class should only have a single responsibility or single
purpose in your project.
● This issue arises when developers ignore creating additional classes during the project’s
initial phase and plan to do that later. Unfortunately, they continue adding more
responsibilities to the initial class that even other functions and methods depend solely on.
In most cases, it is perceived as the application’s main class.
● Ex: guest_email_settings, guest_sms_settings

9. 6- Hard Coding
● This anti-pattern is most common in web development. A developer directly adds various parameters
into the source code instead of fetching them from, say, a database, API, user input, the ‘.env’ file,
etc.
● Two main issues arise with this anti-pattern. The first is security. If you hardcode an authentication
parameter such as an API access token or JWT token, somebody can easily access it by just viewing
the source code from the browser.
● The other issue is environmental change. When you hardcode parameters when working in
“development,” your application will work perfectly. However, the application breaks when you push
the changes to the “production” environment. You will need to edit the source code every time to suit
every environment.

10. 7- Boat Anchor
● This anti-pattern mainly arises when developers code an application with the “what if” question in
mind. What if I need to add this functionality in the future? What if this particular scenario occurs in
my code while in production? What if a user tries to access this feature?
● With all these “what if” questions in mind, developers eventually write additional lines of code not
needed by the application at that particular moment. According to them, these extra lines might
become helpful in the future. Unfortunately, this anti-pattern does more harm than good.
● This “unneeded” code becomes like a “boat anchor” It does nothing as of that moment, but your
application still has to carry it because you think you might require that code in the future.

11. 8- Lava Flow
● Lava flow anti-pattern refers to the concept where developers have to deal with redundant or
low-quality code but appears to have a role in the general working of the application.
Removing or editing this code becomes quite risky since you are unaware of what will
happen to the app.
● Most of these issues arise from legacy code written during the project’s initial phase. Maybe
the developer did not follow the documentation, or the project was moving too fast, and they
didn’t have time to optimize and refactor the code.
● The best solution to lava flows is extensive testing and refactoring. Unfortunately, it’s easier
said than done. Developers will spend much time trying to understand the code, and they
might end up leaving it as it is for fear of breaking the application.

12. 9- Copy – Paste Programming
● most copy and paste code snippets from stack overflow, GitHub, blogs, and youtube videos.
● Unfortunately, most developers don’t analyze the impact of this copy-pasted code; the only
thing that matters is that “it works!”
● You should test this copied code very well and make sure it covers all your test cases!

13. 10- Cargo – Cult Programming
● This anti-pattern derives its name from an interesting story. After the second world war,
tribal societies from the south pacific came into contact with the advanced Western
Civilization. It was the first time for the natives to see manufactured products such as radios,
Coca-Cola, etc., brought to the island.
● Since they had never seen such things (cargo) before and didn’t understand how they were
manufactured, they saw the Americans as gods. They started imitating whatever the
Westerners were doing, hoping the gods would send more cargo to the island. That led to the
rise of the name “cargo cults.”