principle-design-patterns

You can identify software design patterns to avoid by checking for common anti-patterns like Singleton, God object, and Pattern-itis. These architectural pitfalls often signal unnecessary complexity or tight coupling, indicating when a pattern is overkill for your current refactoring scenario.

You need dependency injection in object-oriented design when designing dependency wiring for testability and decoupling construction. Using composition-root DI allows you to inject runtime behaviors, avoiding hardcoded dependencies and making your functional requirements easier to test.

The best way to adapt legacy or third-party interfaces without widespread rewrites is using the Adapter or Facade pattern. These structural patterns map incompatible interfaces to your target object model, isolating legacy integration and preventing cross-cutting concerns from forcing rewrites.

Yes, you can use functions, middleware, events, or reactive streams as modern alternatives to traditional GoF design patterns. When evaluating pattern selection, checking for overkill scenarios often reveals that functional composition or reactive streams provide simpler runtime behavior selection.

To organize persistence behind collections in object-oriented design, you should apply the Repository pattern. This design pattern centralizes data access logic, abstracting persistence operations behind a collection-like interface to cleanly separate infrastructure from your domain object interactions.