🎭Design Patterns

Design Patterns in Different Programming Languages

Updated 2026-05-15

10 min read

Design Patterns in Different Programming Languages

Introduction

Design patterns are reusable solutions to common problems in software design. They provide a standardized approach to solving issues that arise during the development of software systems. Understanding and applying these patterns can significantly improve code quality, maintainability, and scalability.

In this tutorial, we will explore how different programming languages implement various design patterns. We'll compare and contrast their approaches, highlighting the unique features and idioms of each language.

Concept

Design patterns are categorized into three main types:

Creational Patterns: These patterns deal with object creation mechanisms.
Structural Patterns: These patterns explain how to assemble objects into larger structures.
Behavioral Patterns: These patterns focus on the interaction between objects.

Each programming language has its own syntax and paradigms, which influence how design patterns are implemented. Let's dive into some examples across different languages.

Examples

1. Singleton Pattern

The Singleton pattern ensures that a class has only one instance and provides a global point of access to it.

Java

In Java, the Singleton pattern can be implemented using private constructors and static methods.

Java

1public class Singleton {
2  private static Singleton instance;
3 
4  private Singleton() {}
5 
6  public static synchronized Singleton getInstance() {
7      if (instance == null) {
8          instance = new Singleton();
9      }
10      return instance;
11  }
12}

Python

Python's simplicity allows for a more concise implementation using metaclasses or decorators.

Python

1class SingletonMeta(type):
2  _instances = {}
3 
4  def __call__(cls, *args, **kwargs):
5      if cls not in cls._instances:
6          instance = super().__call__(*args, **kwargs)
7          cls._instances[cls] = instance
8      return cls._instances[cls]
9 
10class Singleton(metaclass=SingletonMeta):
11  pass

2. Observer Pattern

The Observer pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

C#

In C#, the Observer pattern can be implemented using events and delegates.

csharp

1public class Subject {
2  private List<IObserver> observers = new List<IObserver>();
3  public int State { get; set; }
4 
5  public void Attach(IObserver observer) {
6      observers.Add(observer);
7  }
8 
9  public void Detach(IObserver observer) {
10      observers.Remove(observer);
11  }
12 
13  public void Notify() {
14      foreach (var observer in observers) {
15          observer.Update(State);
16      }
17  }
18}
19 
20public interface IObserver {
21  void Update(int state);
22}

JavaScript

JavaScript's dynamic nature allows for flexible implementations using functions and callbacks.

JavaScript

1class Subject {
2  constructor() {
3      this.observers = [];
4      this.state = null;
5  }
6 
7  attach(observer) {
8      this.observers.push(observer);
9  }
10 
11  detach(observer) {
12      this.observers = this.observers.filter(obs => obs !== observer);
13  }
14 
15  notify() {
16      this.observers.forEach(observer => observer.update(this.state));
17  }
18}
19 
20class Observer {
21  constructor(subject) {
22      this.subject = subject;
23      this.subject.attach(this);
24  }
25 
26  update(state) {
27      console.log(`Observer state updated to: ${state}`);
28  }
29}

3. Strategy Pattern

The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable.

Ruby

Ruby's dynamic typing and blocks make it easy to implement the Strategy pattern.

Ruby

1class Context
2attr_accessor :strategy
3 
4def initialize(strategy)
5  @strategy = strategy
6end
7 
8def execute_strategy(data)
9  @strategy.execute(data)
10end
11end
12 
13module Strategy
14class ConcreteStrategyA
15  def execute(data)
16    puts "Executing strategy A with data: #{data}"
17  end
18end
19 
20class ConcreteStrategyB
21  def execute(data)
22    puts "Executing strategy B with data: #{data}"
23  end
24end
25end
26 
27context = Context.new(Strategy::ConcreteStrategyA.new)
28context.execute_strategy("Hello")
29 
30context.strategy = Strategy::ConcreteStrategyB.new
31context.execute_strategy("World")

Go

Go's type system and interfaces provide a strong implementation of the Strategy pattern.

1package main
2 
3import "fmt"
4 
5type Strategy interface {
6  Execute(data string)
7}
8 
9type ConcreteStrategyA struct{}
10 
11func (s *ConcreteStrategyA) Execute(data string) {
12  fmt.Printf("Executing strategy A with data: %s
13", data)
14}
15 
16type ConcreteStrategyB struct{}
17 
18func (s *ConcreteStrategyB) Execute(data string) {
19  fmt.Printf("Executing strategy B with data: %s
20", data)
21}
22 
23type Context struct {
24  Strategy Strategy
25}
26 
27func (c *Context) SetStrategy(strategy Strategy) {
28  c.Strategy = strategy
29}
30 
31func (c *Context) ExecuteStrategy(data string) {
32  if c.Strategy != nil {
33      c.Strategy.Execute(data)
34  }
35}
36 
37func main() {
38  context := &Context{}
39  context.SetStrategy(&ConcreteStrategyA{})
40  context.ExecuteStrategy("Hello")
41 
42  context.SetStrategy(&ConcreteStrategyB{})
43  context.ExecuteStrategy("World")
44}

What's Next?

In the next section, we will explore "Anti-Patterns in Software Design," which are common mistakes that should be avoided to maintain clean and efficient codebases.

By understanding both design patterns and anti-patterns, you can become a more proficient developer capable of writing robust and scalable software.

🎭Design Patterns

Design Patterns in Different Programming Languages

Updated 2026-05-15

10 min read

Design Patterns in Different Programming Languages

Introduction

Concept

Design patterns are categorized into three main types:

Creational Patterns: These patterns deal with object creation mechanisms.
Structural Patterns: These patterns explain how to assemble objects into larger structures.
Behavioral Patterns: These patterns focus on the interaction between objects.

Each programming language has its own syntax and paradigms, which influence how design patterns are implemented. Let's dive into some examples across different languages.

Examples

1. Singleton Pattern

The Singleton pattern ensures that a class has only one instance and provides a global point of access to it.

Java

In Java, the Singleton pattern can be implemented using private constructors and static methods.

Java

1public class Singleton {
2  private static Singleton instance;
3 
4  private Singleton() {}
5 
6  public static synchronized Singleton getInstance() {
7      if (instance == null) {
8          instance = new Singleton();
9      }
10      return instance;
11  }
12}

Python

Python's simplicity allows for a more concise implementation using metaclasses or decorators.

Python

1class SingletonMeta(type):
2  _instances = {}
3 
4  def __call__(cls, *args, **kwargs):
5      if cls not in cls._instances:
6          instance = super().__call__(*args, **kwargs)
7          cls._instances[cls] = instance
8      return cls._instances[cls]
9 
10class Singleton(metaclass=SingletonMeta):
11  pass

2. Observer Pattern

The Observer pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

C#

In C#, the Observer pattern can be implemented using events and delegates.

csharp

1public class Subject {
2  private List<IObserver> observers = new List<IObserver>();
3  public int State { get; set; }
4 
5  public void Attach(IObserver observer) {
6      observers.Add(observer);
7  }
8 
9  public void Detach(IObserver observer) {
10      observers.Remove(observer);
11  }
12 
13  public void Notify() {
14      foreach (var observer in observers) {
15          observer.Update(State);
16      }
17  }
18}
19 
20public interface IObserver {
21  void Update(int state);
22}

JavaScript

JavaScript's dynamic nature allows for flexible implementations using functions and callbacks.

JavaScript

1class Subject {
2  constructor() {
3      this.observers = [];
4      this.state = null;
5  }
6 
7  attach(observer) {
8      this.observers.push(observer);
9  }
10 
11  detach(observer) {
12      this.observers = this.observers.filter(obs => obs !== observer);
13  }
14 
15  notify() {
16      this.observers.forEach(observer => observer.update(this.state));
17  }
18}
19 
20class Observer {
21  constructor(subject) {
22      this.subject = subject;
23      this.subject.attach(this);
24  }
25 
26  update(state) {
27      console.log(`Observer state updated to: ${state}`);
28  }
29}

3. Strategy Pattern

The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable.

Ruby

Ruby's dynamic typing and blocks make it easy to implement the Strategy pattern.

Ruby

1class Context
2attr_accessor :strategy
3 
4def initialize(strategy)
5  @strategy = strategy
6end
7 
8def execute_strategy(data)
9  @strategy.execute(data)
10end
11end
12 
13module Strategy
14class ConcreteStrategyA
15  def execute(data)
16    puts "Executing strategy A with data: #{data}"
17  end
18end
19 
20class ConcreteStrategyB
21  def execute(data)
22    puts "Executing strategy B with data: #{data}"
23  end
24end
25end
26 
27context = Context.new(Strategy::ConcreteStrategyA.new)
28context.execute_strategy("Hello")
29 
30context.strategy = Strategy::ConcreteStrategyB.new
31context.execute_strategy("World")

Go

Go's type system and interfaces provide a strong implementation of the Strategy pattern.

1package main
2 
3import "fmt"
4 
5type Strategy interface {
6  Execute(data string)
7}
8 
9type ConcreteStrategyA struct{}
10 
11func (s *ConcreteStrategyA) Execute(data string) {
12  fmt.Printf("Executing strategy A with data: %s
13", data)
14}
15 
16type ConcreteStrategyB struct{}
17 
18func (s *ConcreteStrategyB) Execute(data string) {
19  fmt.Printf("Executing strategy B with data: %s
20", data)
21}
22 
23type Context struct {
24  Strategy Strategy
25}
26 
27func (c *Context) SetStrategy(strategy Strategy) {
28  c.Strategy = strategy
29}
30 
31func (c *Context) ExecuteStrategy(data string) {
32  if c.Strategy != nil {
33      c.Strategy.Execute(data)
34  }
35}
36 
37func main() {
38  context := &Context{}
39  context.SetStrategy(&ConcreteStrategyA{})
40  context.ExecuteStrategy("Hello")
41 
42  context.SetStrategy(&ConcreteStrategyB{})
43  context.ExecuteStrategy("World")
44}

What's Next?

In the next section, we will explore "Anti-Patterns in Software Design," which are common mistakes that should be avoided to maintain clean and efficient codebases.

By understanding both design patterns and anti-patterns, you can become a more proficient developer capable of writing robust and scalable software.