รูปแบบต่อต้านและต้นทุนจากการใช้รูปแบบอย่างผิดวิธี

Now that you know what design patterns are, an equally important skill is knowing when not to use them.

Misapplied patterns add complexity without benefit. This lesson covers anti-patterns and pattern overuse.

An anti-pattern is a common solution that looks helpful but causes more problems than it solves.

Like patterns, anti-patterns recur across projects, so naming them helps teams spot and avoid them.

The God Object is a class that knows or does too much. It accumulates responsibilities until it becomes impossible to change safely.

It violates cohesion and the Single Responsibility Principle.

Spaghetti code has tangled control flow with no clear structure, often from deeply nested conditionals and global state.

It is hard to follow and small changes have unpredictable ripple effects.

The Golden Hammer anti-pattern is over-relying on one familiar tool: if all you have is a hammer, everything looks like a nail.

Forcing the Singleton or Observer pattern onto every problem is a classic example.

Over-engineering adds flexibility for needs that may never arise. A simple value gets wrapped in three factories, a builder, and a strategy interface.

This bloats the codebase and hides the actual logic.

Closely related: abstracting before you understand the variation. Two similar lines do not yet justify an interface.

The Rule of Three suggests waiting until you see a pattern repeat three times before abstracting it.

The Singleton is a legitimate pattern but a frequent anti-pattern. Overused, it becomes hidden global state that makes testing and reasoning hard.

Prefer passing dependencies explicitly over reaching for a global Singleton.

Two guiding acronyms protect against pattern abuse:

• YAGNI — You Are not Gonna Need It; do not build for hypothetical futures
• KISS — Keep It Simple; the simplest design that works is usually best

Reach for a pattern only when a real problem demands it.

Before applying a pattern, ask:

• What concrete problem does it solve here?
• Is there a simpler option?
• Will it make the code easier or harder to read?

A pattern that improves clarity is good; one that adds ceremony is not.

The healthiest approach is to let patterns emerge. Write the simple solution, and when duplication or rigidity appears, refactor toward the pattern that fixes it.

This avoids both anti-patterns and over-engineering.

You learned to avoid the dark side of patterns.

• Anti-patterns like God Object, spaghetti code, and Golden Hammer recur and harm code
• Over-engineering and premature abstraction add needless complexity
• YAGNI and KISS keep designs lean
• Let patterns emerge through refactoring rather than forcing them

Knowing when not to use a pattern is as valuable as knowing the patterns themselves.