How have the GoF Design Patterns Evolved in reaction to Functional Programming and Microservices Architectures? [closed]

The Gang of Four (GoF) book: "Design Patterns: Elements of Reusable Object-Oriented Software", by Erich Gamma, John Vlissides, Richard Helms and Ralph Johnson, in 1994, introduced 23 design patterns to solve recurring software design problems in object-oriented programming. While these patterns remain influential, modern paradigms such as functional programming, microservices, and cloud-native architectures seem to have changed how many of them are applied or whether they are needed at all. I'm interested in how GoF patterns have evolved into today’s development landscape. Specifically: Which GoF patterns have become less relevant or redundant due to advancements in OOP, functional programming, microservices, or modern language features? For example: The Singleton pattern now seems to be discouraged due to its impact on testability and scalability patterns like Factory and Strategy may be unnecessary in languages with first-class functions and closures. Reference: Why is Singleton Design Pattern is Considered an Anti-pattern?, Does Functional Programming Replace GoF Design Patterns? How do functional programming paradigms change the need for certain GoF patterns? Many GoF patterns were designed to compensate for OOP limitations. Are patterns like Command, Strategy, or Decorator replaced by higher-order functions, immutability, or monads in functional programming? What modern alternatives exist for GoF patterns in microservices and distributed architectures? Reference: Where are all the functional programming design patterns? In monolithic applications, patterns like Repository were common. How have event-driven architectures, API gateways, or CQRS changed these approaches? How do SOLID principles influence the use (or avoidance) of certain GoF patterns today? Many GoF patterns align with SOLID (e.g., Strategy aligns with the Open/Closed Principle). Are there cases where SOLID makes traditional GoF patterns redundant or unnecessary? I’d love to hear practical insights from developers working with modern architectures. Which traditional GoF patterns have you adapted, abandoned, or replaced in your work?

Mar 6, 2025 - 23:03

The Gang of Four (GoF) book: "Design Patterns: Elements of Reusable Object-Oriented Software", by Erich Gamma, John Vlissides, Richard Helms and Ralph Johnson, in 1994, introduced 23 design patterns to solve recurring software design problems in object-oriented programming. While these patterns remain influential, modern paradigms such as functional programming, microservices, and cloud-native architectures seem to have changed how many of them are applied or whether they are needed at all.

I'm interested in how GoF patterns have evolved into today’s development landscape. Specifically:

Which GoF patterns have become less relevant or redundant due to advancements in OOP, functional programming, microservices, or modern language features? For example:
- The Singleton pattern now seems to be discouraged due to its impact on testability and scalability
- patterns like Factory and Strategy may be unnecessary in languages with first-class functions and closures.
- Reference: Why is Singleton Design Pattern is Considered an Anti-pattern?, Does Functional Programming Replace GoF Design Patterns?
How do functional programming paradigms change the need for certain GoF patterns?
- Many GoF patterns were designed to compensate for OOP limitations.
- Are patterns like Command, Strategy, or Decorator replaced by higher-order functions, immutability, or monads in functional programming?
- What modern alternatives exist for GoF patterns in microservices and distributed architectures?
- Reference: Where are all the functional programming design patterns?
In monolithic applications, patterns like Repository were common.
- How have event-driven architectures, API gateways, or CQRS changed these approaches?
- How do SOLID principles influence the use (or avoidance) of certain GoF patterns today?
Many GoF patterns align with SOLID (e.g., Strategy aligns with the Open/Closed Principle).
- Are there cases where SOLID makes traditional GoF patterns redundant or unnecessary?

I’d love to hear practical insights from developers working with modern architectures. Which traditional GoF patterns have you adapted, abandoned, or replaced in your work?