Design Patterns - A Quick Guide

Design Patterns are reusable solutions to common problems that arise during software design and development. They provide a structured approach to solving specific challenges, making code more maintainable, flexible, and efficient. Here are some key points about design patterns:

1. Purpose of Design Pattern

   • Design patterns address recurring design problems by capturing best practices and proven solutions.

   • They promote code organisation, modularity, and separation of concerns.

2. Types of Design Patterns

   • Creational Patterns - Focus on object creation mechanisms e.g. Singleton, Factory Method, Abstract Factory, Builder, Prototype.

   • Structural Patterns - Deal with the composition of classes and objects e.g Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy.

   • Behavioural Patterns - Define how objects interact and communicate e.g. Observer, Strategy, Command, Chain of Responsibility, State, Template Method, Visitor.

3. Common Elements in Design Patterns

   • Participants - Classes or objects involved in the pattern (e.g., client, concrete classes, interfaces).

   • Intent - The problem the pattern aims to solve.

   • Motivation - Why the pattern is useful and when to apply it.

   • Structure - Diagram showing the relationships between participants.

4. When to Use Design Patterns?

   • Encounter recurring design problems.

   • Want to improve code quality, maintainability, and scalability.

   • Need to abstract complex interactions or behaviours.

   • Want to follow established best practices.

5. Pattern Trade-offs

   • Patterns introduce additional complexity.

   • Overusing patterns can lead to unnecessary abstraction.

   • Choose patterns wisely based on the problem context.

6. Main reasons for using Design Patterns

   Reusability

   • Design patterns provide reusable solutions to common problems. Instead of reinventing the wheel, developers can apply well-established patterns to solve specific issues.

   • By reusing patterns, development time is reduced, and code quality improves.

Scalability and Maintainability

• As systems grow, maintaining and extending them becomes challenging. Design patterns help manage complexity by organizing code into manageable components.

• Patterns ensure that changes in one part of the system don’t affect other parts, making maintenance easier.

Abstraction and Encapsulation

• Design patterns encourage abstraction, allowing developers to focus on high-level concepts rather than low-level details.

• Encapsulation ensures that implementation details are hidden, promoting modular and maintainable code.

Consistency and Best Practices

• Patterns follow established best practices, leading to consistent code across projects.

• Developers can rely on proven solutions rather than experimenting with untested approaches.

Communication and Collaboration

• Design patterns provide a common vocabulary for developers to discuss and communicate design decisions.

• When team members understand patterns, collaboration becomes smoother.

Flexibility and Adaptability

• Patterns allow systems to adapt to changing requirements without major rework.

• By separating concerns, patterns make it easier to modify or extend specific parts of the system.

Performance Optimisation

• Some patterns optimise performance by reducing redundant computations or minimising resource usage.

• For example, the Singleton pattern ensures a single instance, saving memory.

In summary, design patterns enhance code quality, promote best practices, and facilitate collaboration among developers. They are essential tools for building robust, maintainable, and scalable software systems. 😊

Let’s quickly explore few key design patterns and provide a concise overview, use cases, and examples for each one.

1. Singleton Design Pattern

• Description

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

  • It restricts the instantiation of a class to a single object throughout the application lifecycle.

• Where it is can be used?

  • Managing database connections (ensuring only one connection exists).

  • Logger instances (single logger shared across components).

• Problem it solves

  • Ensures a single point of access to a resource.

  • Prevents multiple instances and reduces memory overhead.

• Simple Example in Java

    public class DatabaseConnection {
        private static DatabaseConnection instance;
  
        private DatabaseConnection() {
            // Initialize database connection
        }
  
        public static DatabaseConnection getInstance() {
            if (instance == null) {
                instance = new DatabaseConnection();
            }
            return instance;
        }
    }
  

2. Factory Method Design Pattern

• • The Factory Method pattern defines an interface for creating objects but allows subclasses to decide which class to instantiate.

    • Promotes loose coupling by delegating object creation to subclasses.

• Where it is can be used?

  • Creating different types of file readers (e.g., XML, JSON, CSV).

  • Abstracting object creation in GUI frameworks.

• Problem it solves

  • Decouples object creation from client code.

  • Provides flexibility for creating objects based on conditions.

• Simple Example in Java

    interface DocumentReader {
        void read();
    }
  
    class XMLReader implements DocumentReader {
        public void read() {
            System.out.println("Reading XML document");
        }
    }
  
    class JSONReader implements DocumentReader {
        public void read() {
            System.out.println("Reading JSON document");
        }
    }
  
    // Factory method
    class DocumentReaderFactory {
        public DocumentReader createReader(String fileType) {
            if ("xml".equalsIgnoreCase(fileType)) {
                return new XMLReader();
            } else if ("json".equalsIgnoreCase(fileType)) {
                return new JSONReader();
            }
            return null;
        }
    }
  

3. Facade Design Pattern

• • The Facade pattern simplifies complex subsystems by providing a unified interface.

    • Acts as a high-level entry point that hides subsystem details.

• Where it can be used?

  • Wrapping complex APIs or libraries with a simpler interface.

  • Providing a unified entry point for a subsystem.

• Problem it solves

  • Reduces complexity and improves readability.

  • Encapsulates subsystem interactions.

• Simple Example in Java:

    class SubsystemA {
        void operationA() {
            System.out.println("Subsystem A operation");
        }
    }
  
    class SubsystemB {
        void operationB() {
            System.out.println("Subsystem B operation");
        }
    }
  
    class Facade {
        private final SubsystemA subsystemA;
        private final SubsystemB subsystemB;
  
        Facade() {
            subsystemA = new SubsystemA();
            subsystemB = new SubsystemB();
        }
  
        void doWork() {
            subsystemA.operationA();
            subsystemB.operationB();
        }
    }
  

These design patterns provide reusable solutions to common problems in system design. Remember to choose the right pattern based on your specific requirements and context. If you’d like more examples or details, feel free to ask!