> For the complete documentation index, see [llms.txt](https://www.pranaypourkar.co.in/the-programmers-guide/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://www.pranaypourkar.co.in/the-programmers-guide/java/code-quality-and-analysis/anti-patterns/types-of-anti-patterns.md). # Types of Anti-Patterns ## About Anti-patterns can be classified based on **where** they appear in software development from low-level code issues to large-scale architectural problems. Understanding their types helps identify problems early and guide effective refactoring. ## 1. **Code-Level Anti-Patterns** These anti-patterns occur in the implementation of logic and syntax. They often result from rushed development, lack of refactoring, or misunderstanding of language features.

Anti-Pattern	Description
Magic Numbers/Strings	Using hardcoded values in code instead of named constants, making code difficult to understand or change.
Copy-Paste Programming	Repeating the same code across multiple places instead of reusing methods or abstractions.
Long Methods	Functions that do too much, reducing readability and reusability.
Commented-Out Code	Leaving large chunks of old code commented instead of removing it cleanly.
Excessive Logging	Filling code with unnecessary or verbose log statements, obscuring useful information.

## 2. **Design Anti-Patterns** These are poor object-oriented design decisions that lead to tightly coupled, fragile systems and hinder extensibility.

Anti-Pattern	Description
God Object / Blob	A class that knows too much or does too many things, violating the Single Responsibility Principle.
Lava Flow	Code that’s outdated or redundant but remains in the system out of fear of breaking things.
Poltergeist	Short-lived, unnecessary objects (often created just to call another object).
Overuse of Inheritance	Relying on deep inheritance hierarchies instead of favoring composition.
Circular Dependencies	Classes or modules that directly or indirectly depend on each other, making code brittle and hard to maintain.

## 3. **Architectural Anti-Patterns** These affect the high-level structure of systems and often emerge due to poor planning or lack of clear architectural vision.

Anti-Pattern	Description
Big Ball of Mud	A system with no discernible structure, where everything is interconnected and difficult to maintain.
Golden Hammer	Applying a familiar tool or pattern to every problem, regardless of its suitability.
Stovepipe System	Independent systems or modules with little to no integration or reuse.
Reinventing the Wheel	Creating custom solutions for problems already solved by mature libraries or tools.
Vendor Lock-in	Overdependence on a single vendor’s technologies, reducing flexibility and portability.

## 4. **Concurrency Anti-Patterns** These appear in multi-threaded or asynchronous programming and can lead to serious performance or correctness issues.

Anti-Pattern	Description
Busy Waiting	Continuously checking a condition in a loop, wasting CPU cycles instead of using efficient wait mechanisms.
Thread-Per-Request	Spawning a new thread for every task, which does not scale well under load.
Unsafe Publication	Sharing objects between threads without proper synchronization, leading to visibility problems.
Double-Checked Locking (Pre-Java 5)	Incorrectly implemented lazy initialization in a multithreaded context.

## 5. **Project & Process Anti-Patterns** These deal with team practices, software processes, and development workflows that undermine software quality over time.

Anti-Pattern	Description
Premature Optimization	Focusing on performance improvements before correctness or clear need.
Design by Committee	Too many stakeholders making conflicting design decisions, leading to diluted outcomes.
Cargo Cult Programming	Using patterns or frameworks without understanding why or how they work.
Over-Engineering	Designing systems with unnecessary flexibility or complexity that’s never used.
Failure to Refactor	Accumulating technical debt due to fear or laziness in cleaning up messy code.

--- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://www.pranaypourkar.co.in/the-programmers-guide/java/code-quality-and-analysis/anti-patterns/types-of-anti-patterns.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.