S/W Design

Low-level design (LLD)

Design patterns

Design patterns are all about polymorphism and indirection. Most of them are applied on the object level. Some of them are on the class level. I have inserted many links below that will help you to understand design patterns with example codes.

Book reference -Gof  Design pattern.

Note: I'd like to suggest that you read "DESIGN PATTERNS: ELEMENTS OF REUSABLE OBJECT ORIENTED SOFTWARE book."

• • Structural design pattern - This category of patterns will help us to achieve structural flexibility. Imagine your S/W system as a black box with N number of components/structures. Including (N +1) or removing (N -1) an arrangement should not disturb old/existing structures. Plus, adding or removing them is easily achievable. It will help us to have a smooth maintenance face of SDLC. 

    • 1. Proxy design pattern

      2. Composite design pattern  

      3. Flyweight design pattern.

      4. Adapter design pattern for beginners.

      5. Decorator design pattern for beginners.

      6. Bridge design pattern.

      7. Facade design pattern

  • Behavioral design pattern - This category of patterns will help us to achieve behavioral flexibility. Imagine your S/W system as a black box with N number of behaviors. What do we mean by behaviors? Functionalities we offer from public APIs. Including (N +1) or removing (N -1) behavior should not disturb existing S/W. Plus, adding or removing behaviors is easily achievable. Our S/W should be easily extendable.

    • 1. Command design pattern

      2. Memento design pattern. 

      3. Mediator design pattern

      4. Visitor design pattern for beginners.

      5. State design pattern for beginners.

      6. Iterator design pattern for beginners.

      7. Observer design pattern.

      8. Strategy design pattern. Sometimes called policy pattern.

      9. Template method design pattern for beginners.

      10. Chain of responsibility design pattern.

      11. Interpreter design pattern

  • Creational design pattern - Classes are just a blueprint; instances of those classes (called objects) are the real things. Created in memory. There are many relationships between objects present in OOPs (i.e., Composition, Aggregation, Inheritance, usage, etc.). In enterprise-level big applications, creating an object has many prerequisites. One of them could be - before creating object X. You should have object Y in place. And to create object Y, you should have config files loaded and parsed into the memory. Deleting or cleaning one object should not create dangling pointers/references to other objects. Like different categories of patterns, this category has also been designed to achieve flexibility. Creational flexibility. We should be able to address clean creation/deletion of objects which can become easily extendable for newly created structures/behaviors. 

    • 1. Builder design pattern

      2. Factory method design pattern for beginners.

      3. Abstract factory design pattern.

      4. Singleton design pattern.

      5. Prototype design pattern for beginners.

Book reference - Pattern-Oriented Software Architecture V-2.

Note: - I want to recommend you to read this book. Below links are for quick UMLs and C++ code reference on those patterns.

• • Prerequisites 

    • Socket programming

    • Multithreading

  • Service  Access and Configuration Patterns

    • Wrapper facade

    • Component configurator

    • Interceptor

    • Extension interface

  • Event Handling patterns

    • Reactor or Dispatcher

    • Proactor

    • Asynchronous completion token

    • Acceptor concretor 

  • Synchronization patterns

    • Scoped locking

    • Strategized Locking

    • Thread-Safe Interface

    • Double-Checked Locking Optimization

  • Concurrency patterns

    • Active Object

    • Monitor Object

    • Half-Sync - Half-Async

    • Leader - Followers

    • Thread-Specific Storage