Design Patterns

This repository explores several creational design patterns, which are used to create objects in a manner suitable to the situation. Below is a collection of five key creational patterns with a brief overview and example for each:

A) Creational Design Patterns

1. Singleton Pattern

What it is:
The Singleton Pattern ensures a class has only one instance and provides a global point of access to that instance.
Purpose:
The Singleton pattern aims to limit the number of instances of a class to just one and ensure that this single instance is accessible throughout the application.
Key Characteristics:
- Single instance: Only one instance of the class exists in the application.
- Global access: The instance can be accessed globally throughout the application.
- Lazy initialization: The instance is created when needed, preventing unnecessary resource usage if not accessed.
Examples:

Database Connection Pooling A singleton ensures there is only one instance of the database connection pool in the application, providing a centralized point for managing database connections and reducing the overhead of creating multiple connections.
Configuration Management In large enterprise applications, a singleton can be used to store and manage configuration settings globally, ensuring that all components access the same configuration object and preventing inconsistencies.
Logging Systems A singleton logger is used across an application to ensure that only one instance handles log writing, reducing the complexity of managing multiple loggers and ensuring consistency in logging output. Example Logging Systems - Singleton Pattern
Cache Management A singleton can be used to manage a global cache in an enterprise application, allowing all components to share the same cache instance and reduce the overhead of maintaining multiple caches.
Session Management In web applications, a singleton can manage user sessions, ensuring that there is a single session manager responsible for handling user sessions across the application, preventing session duplication.
Thread Pooling The singleton pattern is used for managing a thread pool where a single instance is responsible for managing and providing access to a pool of reusable threads for concurrent tasks.
Application State Management In enterprise applications, a singleton can be used to manage global application state, ensuring that all parts of the application interact with the same instance and have a consistent view of the state.
Event Bus A singleton event bus or message bus can be used to manage communication between different parts of an application, ensuring that all components share the same event bus for decoupled and consistent message passing.
Security Token Management In security-heavy applications, a singleton can be used to manage a global security token or authentication manager, ensuring a single, consistent instance handles authentication and authorization across the system.
Resource Managers (e.g., Printer, File System) A singleton pattern can be applied to manage shared resources, such as printer management or file system access, to ensure that there is a single instance controlling access to these shared resources, avoiding conflicts and resource contention.

2. Factory Method Pattern

What it is: Defines an interface for creating a single object, but lets subclasses decide which class to instantiate. It focuses on one product and delegates the instantiation to subclasses.
Purpose:
To delegate object instantiation to subclasses, allowing for more flexible and dynamic creation of objects.
Key Characteristics:
- Defines an interface for object creation: A method for creating objects is defined in a superclass, but subclasses alter the object type.
- Subclasses control object creation: The specific class to be instantiated is decided by subclasses.
Examples:

Logging Systems Used to create different types of loggers (e.g., file logger, database logger, or console logger) based on configuration, allowing flexible logging strategies in large-scale applications.
Database Connection Pooling The factory method is used to instantiate database connection objects (e.g., MySQL, PostgreSQL, Oracle) dynamically, enabling the application to work with different database types and manage connections efficiently.
Payment Processing Systems A payment gateway might support multiple payment methods (credit card, PayPal, Stripe). The factory method helps decide which payment processor to instantiate based on user selection or configuration. Payment Example
Document Generation Systems In enterprise applications that generate various document formats (PDF, Excel, Word), a factory method can be used to dynamically create the appropriate document type objects, ensuring proper formatting and structure for each type. Document Generation Example
Notification Systems For sending notifications (email, SMS, push notifications), the factory method can be used to create specific notification objects based on the required communication channel, providing flexibility in how notifications are sent.
UI Frameworks In cross-platform applications, a factory method can create platform-specific UI components (e.g., buttons, text fields) based on the operating system (Windows, Mac, Linux), allowing the application to adapt its UI without changing business logic.
Report Generation Tools For generating different types of reports (e.g., financial, sales, inventory), a factory method can be used to generate the appropriate report format, offering the flexibility to create different types based on the user’s choice or configuration.
File Parsing and Processing In applications that need to handle different file formats (CSV, XML, JSON), the factory method can create file parser objects dynamically based on the file type, ensuring the correct processing logic is applied.
Product Manufacturing Systems In enterprise resource planning (ERP) or manufacturing systems, a factory method can be used to create objects representing different types of products (e.g., electronic, mechanical) based on production needs, enhancing flexibility in production line management.
Cloud Service Providers Cloud systems may support multiple cloud providers (AWS, Azure, Google Cloud). A factory method can dynamically create the correct cloud service client, ensuring the application interacts with the right provider’s API based on configuration.
GUI Frameworks A UI framework might have a method to create buttons. The exact type of button, such as WindowsButton or MacButton, would be determined by the operating system and handled by subclasses. Gui Framework Example

3. Abstract Factory Pattern

What it is:
The Abstract Factory Pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.
Purpose:
To create families of related objects that can be used interchangeably, particularly in systems requiring interaction with multiple sets of products.
Key Characteristics:
- Abstracts product families: The factory creates whole families of objects instead of individual objects.
- Product variation: Allows the system to work with different sets of related products (e.g., UI widgets for different operating systems).
Example:

GUI Frameworks (Cross-Platform UI) Different platforms (Windows, macOS, Linux) have different UI components (buttons, text fields, etc.) that need to be created with a platform-specific style. A GUI framework can use an abstract factory to create buttons, text fields, and other UI elements tailored to the operating system (e.g., WindowsFactory, MacFactory, LinuxFactory). Gui Framework Example
Game Engines (Cross-Platform Games) A game needs to render graphics, sound, and input on different platforms (PC, Xbox, PlayStation) with different hardware and APIs. A game engine can use abstract factories like GraphicsFactory, SoundFactory, InputFactory to provide platform-specific implementations (e.g., DirectX, OpenGL, PlayStation SDK).
Database Connectivity (Multiple Databases) An application needs to interact with multiple types of databases (MySQL, PostgreSQL, Oracle), where each database has different ways to connect, query, and manage transactions. The abstract factory can create a family of objects like Connection, Command, and Transaction for each database type (e.g., MySQLFactory, PostgreSQLFactory, OracleFactory).
Web Development (Cross-Browser Compatibility) Different browsers (Chrome, Firefox, Safari) may need different approaches to render elements or interact with JavaScript. A web framework could define an abstract factory to create browser-specific objects like DOMManipulator, EventListener, and CSSRenderer.
Document Processing (Different Formats) A document processing application needs to generate or manipulate documents in different formats like PDF, DOCX, or HTML. An abstract factory could be used to produce objects like Page, Header, Footer that work differently based on the document format (e.g., PDFFactory, DOCXFactory, HTMLFactory).
Reporting Systems (Different Report Types) A system needs to generate various report types such as CSV, PDF, or Excel, each requiring different rendering logic. An abstract factory could create objects like ReportHeader, ReportBody, and ReportFooter that are specific to each report format (e.g., CSVReportFactory, PDFReportFactory, ExcelReportFactory).
Network Protocols (Multiple Protocols) An application needs to interact with multiple communication protocols such as HTTP, FTP, and WebSocket. An abstract factory can define methods to create protocol-specific objects, like Request, Response, and Connection for each protocol (e.g., HTTPFactory, FTPFactory, WebSocketFactory).
E-commerce Systems (Payment Gateways) An e-commerce platform needs to integrate with different payment providers (PayPal, Stripe, Square), each with its own API for processing payments. A payment processor can use an abstract factory to generate objects like PaymentProcessor, PaymentDetails, and Transaction based on the selected payment gateway (e.g., PayPalFactory, StripeFactory, SquareFactory).
Security Systems (Authentication Methods) A security system needs to support various authentication methods (OAuth, SAML, LDAP) for different services. An authentication system can create a family of related objects like Authenticator, TokenValidator, and SessionManager for each method (e.g., OAuthFactory, SAMLFactory, LDAPFactory).
Smart Home Systems (Device Communication) A smart home platform supports different types of devices (lights, thermostats, cameras) from various manufacturers, each with its own communication protocol (Zigbee, Z-Wave, Wi-Fi). The system could use an abstract factory to create device-specific objects like LightControl, ThermostatControl, and CameraControl for each communication protocol (e.g., ZigbeeFactory, ZWaveFactory, WifiFactory).

4. Builder Pattern

What it is:
The Builder Pattern allows the construction of complex objects step by step, separating the construction process from the object's representation.
Purpose:
To construct an object by specifying its type and content, without needing to define the exact class for the object.
Key Characteristics:
- Step-by-step construction: A methodical approach to creating an object.
- Separate construction and representation: The builder focuses on how the product is created, while the representation can vary independently.
Example:
A CarBuilder can create a car with different configurations (engine type, color, and features). Instead of creating the car all at once, the builder allows you to set each part and assemble the car step by step.

5. Prototype Pattern

What it is:
The Prototype Pattern involves creating new objects by copying an existing object (the prototype), rather than constructing a new one from scratch.
Purpose:
To avoid the overhead of creating new instances and instead clone an existing object.
Key Characteristics:
- Cloning: Objects are created by copying an existing prototype.
- Cost-effective: Ideal for situations where creating an object from scratch is expensive or complex.
Example:
If a complex object, such as a large configuration file, needs to be used repeatedly, the prototype pattern can be used to clone it instead of recreating the object every time.

6. Dependency Injection (DI) Pattern

What it is:
Dependency Injection (DI) is a creational pattern that decouples the creation of objects from their usage, injecting dependencies into a class rather than having the class create them itself.
Purpose:
To reduce coupling between classes, making the system more modular and easier to test.
Key Characteristics:
- Decouples object creation: Dependencies are injected into a class instead of being created inside the class.
- Enhances testability: By injecting dependencies, you can easily mock or replace them during unit testing.
Example:
In a Spring-based application, a service might depend on a repository. Instead of the service creating the repository itself, DI allows the repository to be injected into the service through a constructor or setter methods.

These patterns provide a wide range of tools for solving object creation problems in software design. By leveraging them appropriately, developers can build more maintainable, flexible, and scalable applications.

B) Structural Design Patterns

1. Adapter Pattern

What it is:
The Adapter Pattern is a structural design pattern that allows incompatible interfaces to work together. It acts as a bridge between two interfaces, enabling communication between them.
Purpose:
To enable classes with incompatible interfaces to interact without modifying their source code.
Key Characteristics:
- Interface compatibility: The adapter converts one interface to another.
- No need for modifying original code: It allows legacy or incompatible code to work with newer code.
Example:
Imagine you have a LegacyPrinter class that prints documents in a specific format. Now, you want to use a NewPrinter class with a different interface. The Adapter Pattern allows you to create an adapter that makes the NewPrinter class compatible with the LegacyPrinter interface.

2. Bridge Pattern

What it is:
The Bridge Pattern is a structural design pattern that separates an abstraction from its implementation so that both can evolve independently.
Purpose:
To allow you to change the implementation without affecting the abstraction (or vice versa).
Key Characteristics:
- Separation of concerns: Abstraction and implementation are decoupled, allowing both to evolve independently.
- Flexible extensibility: You can extend both the abstraction and implementation without modifying existing code.
Example:
Suppose you have a Shape class with Circle and Rectangle as concrete implementations. You can use the Bridge Pattern to separate the shape's abstraction (e.g., Shape) from the drawing implementation (e.g., DrawingAPI). This way, you can change the shape and drawing implementations independently.

3. Composite Pattern

What it is:
The Composite Pattern is a structural design pattern that allows you to treat individual objects and compositions of objects uniformly.
Purpose:
To compose objects into tree-like structures to represent part-whole hierarchies, where both individual objects and compositions can be treated uniformly.
Key Characteristics:
- Uniformity: Clients can treat individual objects and composite objects the same way.
- Hierarchical structure: Objects are arranged in a tree structure.
Example:
A file system can use the Composite Pattern to treat files and folders uniformly. Both files and folders implement the same interface, allowing you to perform operations (e.g., delete or read) without worrying about whether it is a single file or a folder containing other files.

4. Decorator Pattern

What it is:
The Decorator Pattern is a structural design pattern that allows you to dynamically add behavior to an object at runtime without modifying its code.
Purpose:
To enhance or modify an object’s functionality without changing its core structure.
Key Characteristics:
- Dynamic behavior addition: It allows you to add or remove functionalities at runtime.
- Avoids subclassing: Instead of subclassing, you wrap objects with additional behavior.
Example:
Imagine a Car class that has a basic feature of driving. Using the Decorator Pattern, you could dynamically add additional behaviors (e.g., air conditioning, sunroof) without modifying the original Car class.

5. Facade Pattern

What it is:
The Facade Pattern is a structural design pattern that provides a simplified interface to a complex subsystem, making it easier to use.
Purpose:
To hide the complexities of a system and provide a simpler interface to the client.
Key Characteristics:
- Simplified interface: It provides a higher-level interface that makes the system easier to use.
- Encapsulation of complexity: It abstracts away the complexity of interacting with subsystems.
Example:
A HomeTheaterFacade might provide a simple interface for turning on a home theater system, but internally it interacts with multiple complex subsystems like speakers, lights, and the DVD player.

6. Flyweight Pattern

What it is:
The Flyweight Pattern is a structural design pattern that reduces memory usage by sharing common objects, rather than creating new ones.
Purpose:
To minimize memory usage by sharing as much data as possible between objects.
Key Characteristics:
- Object sharing: Multiple objects share common data.
- Efficient memory usage: Only necessary unique data is stored, and common data is shared.
Example:
In a word processor, each character in the document is an object. Using the Flyweight Pattern, characters that repeat (e.g., 'a', 'b') are shared across all instances, reducing memory usage.

7. Proxy Pattern

What it is:
The Proxy Pattern is a structural design pattern that provides a surrogate or placeholder for another object to control access to it.
Purpose:
To control access to an object by creating a proxy that acts as an intermediary.
Key Characteristics:
- Control access: It controls access to the real object by acting as a stand-in.
- Lazy initialization: In some cases, the proxy can delay the creation of the real object until it's needed.
Example:
A VirtualProxy could be used to delay the creation of a resource-heavy object until it is needed. For instance, a LargeImage class could be accessed through a proxy, and the actual image would only be loaded when it is required.

These structural patterns help in organizing and structuring objects, making systems more efficient, flexible, and easier to maintain. By applying them appropriately, developers can design software that is more scalable and easier to understand.

C) Behavioral Design Patterns

1. Chain of Responsibility Pattern

What it is:
The Chain of Responsibility Pattern is a behavioral design pattern that allows a request to pass through a chain of handlers, where each handler decides whether to process the request or pass it along to the next handler in the chain.
Purpose:
To decouple sender and receiver, allowing multiple objects to process a request without the sender needing to know which object handles it.
Key Characteristics:
- Request passing: The request is passed along the chain of handlers until one of them processes it.
- Dynamic chaining: Handlers can be added or removed dynamically.
Example:
In a logging system, a request for logging can pass through a series of handlers, such as writing logs to a file, a database, or a remote server. Each handler decides if it should handle the request.

2. Command Pattern

What it is:
The Command Pattern is a behavioral design pattern that encapsulates a request as an object, allowing users to parameterize clients with queues, requests, and operations.
Purpose:
To decouple the sender and the receiver, allowing the request to be stored, executed later, or undone.
Key Characteristics:
- Encapsulation of requests: The pattern allows commands to be treated as objects.
- Decoupling sender and receiver: The sender does not need to know the details of the operation being performed.
Example:
Consider a text editor application where actions (like cut, copy, and paste) are encapsulated as commands. These commands can be executed, undone, or stored for future use.

3. Interpreter Pattern

What it is:
The Interpreter Pattern is a behavioral design pattern that provides a way to evaluate language grammar or expressions within a particular context.
Purpose:
To define a representation for a language's grammar and interpret the sentences in the language.
Key Characteristics:
- Grammar-based: The pattern defines a way to interpret sentences based on grammar.
- Recursive structure: It allows defining complex grammar in terms of simpler rules.
Example:
A simple calculator can use the Interpreter Pattern to evaluate arithmetic expressions like 5 + 3 * 2. Each component (e.g., addition, multiplication) can be interpreted according to the rules.

4. Iterator Pattern

What it is:
The Iterator Pattern is a behavioral design pattern that allows sequential access to the elements of a collection without exposing the underlying representation of the collection.
Purpose:
To provide a standard way to traverse a collection of objects without exposing the collection's structure.
Key Characteristics:
- Traversal: It provides a way to traverse the elements of a collection.
- Encapsulation: The underlying collection implementation is hidden from the client.
Example:
A BookCollection class can use an iterator to traverse its collection of books. The client can access each book sequentially, without needing to know how the collection is implemented.

5. Mediator Pattern

What it is:
The Mediator Pattern is a behavioral design pattern that defines an object that controls the interaction between a set of objects, ensuring that the objects don't communicate directly with each other.
Purpose:
To reduce the dependencies between communicating objects, thereby making the system easier to maintain.
Key Characteristics:
- Centralized communication: Objects communicate through a central mediator, instead of directly with each other.
- Decoupling of objects: The mediator handles interactions, reducing dependencies between objects.
Example:
In an air traffic control system, different aircraft (objects) communicate with the control tower (mediator) rather than with each other.

6. Memento Pattern

What it is:
The Memento Pattern is a behavioral design pattern that allows capturing the internal state of an object without exposing its structure, so the object can be restored to that state later.
Purpose:
To enable undo/redo functionality by saving and restoring an object's state.
Key Characteristics:
- State preservation: It allows you to store the object's state and restore it at a later point.
- Encapsulation of internal state: The internal state of an object is captured and stored without exposing it to the outside world.
Example:
In a text editor, each change can be stored as a memento, so users can undo and redo their changes.

7. Observer Pattern

What it is:
The Observer Pattern is a behavioral design pattern that allows a subject to notify its observers automatically when its state changes.
Purpose:
To establish a one-to-many relationship between objects so that when the state of one object (the subject) changes, all dependent objects (observers) are notified.
Key Characteristics:
- Loose coupling: Observers are decoupled from the subject, meaning they don't need to know each other directly.
- Automatic notification: Observers are automatically notified when the subject's state changes.
Example:
In a stock market application, multiple viewers (observers) can track stock price changes. When the stock price changes, all observers are notified and updated automatically.

8. State Pattern

What it is:
The State Pattern is a behavioral design pattern that allows an object to change its behavior when its internal state changes.
Purpose:
To allow an object to appear to change its class based on its current state.
Key Characteristics:
- State-driven behavior: The object's behavior is driven by its current state.
- State transitions: The object transitions from one state to another, changing its behavior accordingly.
Example:
A vending machine can be in different states, such as "idle," "accepting money," and "dispensing item." Based on its state, the behavior of the vending machine changes.

9. Strategy Pattern

What it is:
The Strategy Pattern is a behavioral design pattern that defines a family of algorithms, encapsulates each one, and makes them interchangeable.
Purpose:
To allow a class to choose a behavior at runtime without modifying the class itself.
Key Characteristics:
- Algorithm encapsulation: Different strategies (algorithms) are encapsulated and made interchangeable.
- Runtime selection: The strategy can be selected at runtime based on the context.
Example:
A navigation app can choose different routing strategies (e.g., fastest route, scenic route) based on user preferences or real-time conditions.

10. Template Method Pattern

What it is:
The Template Method Pattern is a behavioral design pattern that defines the structure of an algorithm in a base class, but lets subclasses implement specific steps of the algorithm.
Purpose:
To allow the structure of an algorithm to be defined once, while allowing specific steps to be customized by subclasses.
Key Characteristics:
- Algorithm structure: The algorithm is defined in the base class, with some steps left to be implemented by subclasses.
- Extension and customization: Subclasses can customize specific steps while keeping the overall structure intact.
Example:
A data processing application can have a template method for processing data, with steps like data loading, processing, and saving. Subclasses can implement specific ways to load or process data.

11. Visitor Pattern

What it is:
The Visitor Pattern is a behavioral design pattern that allows adding new operations to objects of different classes without changing the classes themselves.
Purpose:
To separate operations from the objects they operate on, making it easy to add new operations without modifying the objects.
Key Characteristics:
- Separation of concerns: Operations are separated from the objects, which makes it easy to add new operations without altering the objects.
- Extensibility: New operations can be added without modifying the existing object structures.
Example:
In a graphics application, the visitor pattern can be used to add new operations like rendering or calculating the area to various shapes (e.g., Circle, Rectangle) without modifying the shape classes.

These behavioral patterns focus on the interaction between objects and allow you to manage and manipulate complex workflows efficiently. By leveraging them, developers can create flexible and extensible systems that evolve with ease.

D) Concurrency Design Patterns (Multithreading and Concurrency Control)

1. Thread Pool Pattern

What it is:
The Thread Pool Pattern is a concurrency design pattern that maintains a pool of worker threads to execute tasks, reducing the overhead of creating and destroying threads repeatedly.
Purpose:
To manage a fixed number of threads that handle a large number of tasks, improving resource utilization and performance.
Key Characteristics:
- Predefined threads: The pool contains a fixed number of worker threads that are reused to execute tasks.
- Task queuing: Tasks are placed in a queue and processed by available threads from the pool.
Example:
In a web server, a thread pool is used to handle incoming HTTP requests. When a request arrives, it is assigned to an available worker thread from the pool, reducing the overhead of thread creation.

2. Future Pattern

What it is:
The Future Pattern is a concurrency design pattern that provides a placeholder object for a result that is initially unknown but will be computed in the future.
Purpose:
To allow you to perform computations asynchronously and retrieve the result at a later point when it's available.
Key Characteristics:
- Asynchronous computation: The result of the computation is available in the future, allowing other tasks to proceed while waiting for the result.
- Blocking retrieval: When the result is needed, the calling thread blocks until the computation is complete.
Example:
In a multi-threaded application, you might use the Future pattern to execute a database query asynchronously. The main thread can continue doing other work, and when the query result is needed, it can be retrieved from the Future object.

3. Producer-Consumer Pattern

What it is:
The Producer-Consumer Pattern is a concurrency design pattern that separates the tasks of producing data and consuming data into different components, often using a shared buffer or queue.
Purpose:
To decouple the production and consumption of data to allow efficient multitasking, often used in multi-threaded applications where one thread produces data, and another thread consumes it.
Key Characteristics:
- Synchronization: Producers and consumers synchronize their actions using a shared buffer to avoid data inconsistency.
- Buffer/Queue: Data is placed into a buffer (or queue) by producers and retrieved by consumers.
Example:
In a message processing system, one thread (producer) generates messages and places them into a queue, while another thread (consumer) processes the messages from the queue.

4. Read-Write Lock Pattern

What it is:
The Read-Write Lock Pattern is a concurrency design pattern that allows multiple readers to access a resource simultaneously but ensures that writers have exclusive access.
Purpose:
To improve performance by allowing multiple threads to read data concurrently while preventing conflicts when writing data.
Key Characteristics:
- Concurrent reads: Multiple threads can read the resource simultaneously, but only one thread can write.
- Exclusive write access: Writers are granted exclusive access to the resource, preventing reading during writing.
Example:
In a database system, a read-write lock is used to allow multiple users to read data at the same time, but when a user needs to update the data, no other users can read or write to that data until the update is complete.

5. Half-Sync/Half-Async Pattern

What it is:
The Half-Sync/Half-Async Pattern is a concurrency design pattern that separates synchronous and asynchronous processing in a system to improve performance and scalability.
Purpose:
To handle synchronous and asynchronous tasks in separate layers to avoid blocking synchronous processing while allowing efficient handling of asynchronous tasks.
Key Characteristics:
- Synchronization separation: Some parts of the system are handled synchronously (e.g., business logic), while others (e.g., I/O operations) are handled asynchronously.
- Improved scalability: Asynchronous processing allows the system to handle more requests without blocking other operations.
Example:
A web server might handle HTTP requests synchronously but perform database queries asynchronously. This allows the server to quickly process requests while waiting for responses from the database.

These concurrency patterns are designed to enhance performance and scalability, especially in multithreaded systems, by efficiently managing threads, asynchronous operations, and resource access. By implementing these patterns, systems can improve throughput and resource utilization while minimizing contention and overhead.

E) Architectural Design Patterns (High-level Design)

1. Model-View-Controller (MVC) Pattern

What it is:
The Model-View-Controller (MVC) pattern is an architectural design pattern that separates an application into three interconnected components: Model, View, and Controller.
Purpose:
The goal of MVC is to separate concerns, allowing for easier maintenance and scalability of applications by organizing code into distinct roles.
Key Characteristics:
- Model: Represents the data and business logic of the application.
- View: Displays the data (UI) to the user.
- Controller: Handles user input and updates the model or view accordingly.
Example:
In a web application, the user interacts with the UI (View). The Controller manages the user’s actions (e.g., clicking a button) and manipulates the Model (e.g., fetching data from a database), which is then displayed back through the View.

2. Layered Architecture Pattern

What it is:
The Layered Architecture Pattern divides an application into layers, where each layer is responsible for a specific set of tasks, and communicates only with the layer directly below it.
Purpose:
The goal of this pattern is to promote separation of concerns, making the system easier to maintain and extend.
Key Characteristics:
- Layered separation: Each layer has its own responsibility, such as presentation, business logic, data access, etc.
- Low coupling: Layers should only communicate with adjacent layers, improving modularity.
Example:
In a typical web application, you may have a presentation layer (handles UI), a service layer (business logic), and a data access layer (handles database communication).

3. Microservices Architecture Pattern

What it is:
The Microservices Architecture pattern is an architectural style that structures an application as a collection of small, independently deployable services that communicate with each other via lightweight protocols.
Purpose:
The goal is to break down a monolithic system into smaller, more manageable services that can be developed, deployed, and scaled independently.
Key Characteristics:
- Independent services: Each service in a microservices architecture is designed to perform a specific business function and is independently deployable.
- Decentralized data management: Each service often has its own database, promoting autonomy.
Example:
An e-commerce application can have different microservices for user management, order processing, payment, and inventory. Each microservice is independently deployed, allowing for flexibility and scalability.

4. Event-Driven Architecture Pattern

What it is:
The Event-Driven Architecture (EDA) pattern is an architectural style where components communicate by producing and consuming events, usually via an event bus or message queue.
Purpose:
The goal is to decouple components of a system so they can react to events asynchronously, enabling greater scalability and responsiveness.
Key Characteristics:
- Asynchronous communication: Components respond to events when they occur, without waiting for a direct response.
- Loose coupling: Components are not tightly coupled and can be updated independently.
Example:
In a financial transaction system, an event such as a “payment processed” event might trigger other services (e.g., sending a notification or updating an account balance) without them needing to know about each other’s implementation.

5. Client-Server Architecture Pattern

What it is:
The Client-Server Architecture pattern is a distributed computing model where a client requests services or resources, and a server provides them.
Purpose:
The goal is to separate the responsibilities of requesting and providing resources, allowing for scalable and modular application design.
Key Characteristics:
- Separation of concerns: The client focuses on the user interface and interaction, while the server handles business logic and data storage.
- Centralized data: The server typically stores the data, and the client retrieves it as needed.
Example:
A typical web application where the browser (client) requests data from a web server, which processes the request and returns the necessary data (e.g., HTML, JSON) for display.

6. Peer-to-Peer Architecture Pattern

What it is:
The Peer-to-Peer (P2P) Architecture pattern is a decentralized architecture where each node in the network acts as both a client and a server, sharing resources with other peers.
Purpose:
The goal is to distribute resources and processing across multiple nodes, improving scalability and fault tolerance.
Key Characteristics:
- Decentralized communication: There is no central server; each node can communicate directly with other nodes.
- Resource sharing: Nodes share resources, such as processing power or storage, with one another.
Example:
In file-sharing systems like BitTorrent, each user (peer) acts as both a client (requesting files) and a server (sharing files), distributing the load and improving redundancy.

These architectural patterns serve as blueprints for structuring applications at a high level. They are designed to improve system scalability, flexibility, maintainability, and efficiency, making them crucial for modern software design.

Others Design Patterns

1. DTO (Data Transfer Object)

Is it a design pattern?
Yes, DTO is considered a design pattern.
What is it?
A DTO is an object that is used to transfer data between software application subsystems or layers. It is typically used in the context of service-oriented or distributed systems where data needs to be passed over a network or between different layers of an application (e.g., from the database layer to the presentation layer).
Purpose:
DTOs are used to encapsulate data to be transferred, often aggregating multiple fields into one object. This can reduce the number of method calls or the number of objects passed around between layers, improving performance (especially when dealing with large sets of data).
Key Characteristics:
- A DTO does not contain any business logic; it only holds data.
- DTOs are typically serializable, meaning they can be easily converted into formats like JSON, XML, etc., to be transmitted across different systems.
Example:
In a web application, you might have a UserDTO that contains all the details of a user (name, email, address, etc.) and send this DTO over an HTTP response to the frontend.

2. DAO (Data Access Object)

Is it a design pattern?
Yes, DAO is also considered a design pattern.
What is it?
A DAO is a structural pattern that provides an abstract interface to some type of database or other persistence mechanisms. It allows an application to access the data without needing to know the specifics of the underlying storage or database technology.
Purpose:
The DAO pattern separates the data access logic from the rest of the application, allowing the application to interact with a database in an abstract manner. It improves maintainability and flexibility by decoupling the business logic from the data layer.
Key Characteristics:
- DAO typically provides methods like create(), read(), update(), and delete() (CRUD operations).
- It abstracts the complexity of interacting with databases or external systems, allowing for easy changes in data source implementations without affecting the rest of the application.
Example:
In a system that stores user data in a database, you would create a UserDAO that encapsulates all operations related to interacting with the user data in the database (like saving user details, retrieving user information, etc.).

3. Publish-Subscribe Pattern

What it is:
The Publish-Subscribe pattern is a messaging pattern where a "publisher" sends messages (events) to multiple "subscribers" who have expressed interest in receiving those messages. The publisher doesn’t know who the subscribers are, and subscribers are notified when events are published.
Purpose:
This pattern provides a loose coupling between senders and receivers and allows for asynchronous communication without directly linking the sender and receiver.
Key Characteristics:
- Decoupling: Publishers and subscribers are independent.
- Asynchronous communication: Publishers send messages, and subscribers react to them without direct synchronization.
- Scalability: Adding new subscribers does not affect existing components.
Example:
In an event-driven system, a weather station (publisher) sends updates about the weather, and multiple users (subscribers) receive real-time weather data updates.

4. Observer Pattern

What it is:
The Observer pattern is a behavioral design pattern where one object (subject) maintains a list of dependent observers that are notified of any changes to the state of the subject.
Purpose:
Used when multiple objects need to be updated automatically when the state of another object changes without tightly coupling the objects.
Key Characteristics:
- Subject and Observers: The subject notifies all observers of any changes.
- Loose coupling: Observers are unaware of the subject's internal logic.
- Dynamic registration/unregistration: Observers can be added or removed at runtime.
Example:
A stock market application where stock price changes (subject) automatically notify users (observers) of the update.

5. Composite Pattern

What it is:
The Composite pattern is used to treat individual objects and compositions of objects uniformly. It allows you to compose objects into tree-like structures to represent part-whole hierarchies.
Purpose:
It simplifies the handling of both individual objects and composites as a single unit.
Key Characteristics:
- Recursive composition: Components are treated as a part of the whole.
- Uniformity: Both leaf and composite objects are treated uniformly.
Example:
A file system where both files and directories are treated as "objects," and directories can contain files or other directories.

6. Lazy Initialization

What it is:
Lazy Initialization is a design pattern where the creation of an object or resource is deferred until it is actually needed.
Purpose:
To optimize resource usage by delaying the initialization of expensive objects until they are required.
Key Characteristics:
- Deferred creation: Resources are created only when needed.
- Efficiency: Reduces unnecessary memory and CPU usage.
- Thread-safety (optional): Can be combined with thread safety to ensure that the resource is created only once in multi-threaded environments.
Example:
The Singleton pattern often uses lazy initialization, where the instance is only created when it is first requested.

7. Thread-Local Storage Pattern

What it is:
Thread-Local Storage (TLS) is a pattern that provides data that is specific to each thread. Each thread has its own independent copy of data, which prevents data from being shared between threads.
Purpose:
To avoid data sharing between threads in concurrent systems, ensuring thread-specific data is isolated.
Key Characteristics:
- Thread-specific data: Each thread gets its own copy of the data.
- No sharing between threads: Data is not shared, avoiding synchronization issues.
- Improves performance: Reduces contention in multi-threaded environments.
Example:
In a web server, each thread handling a user request may need to store its own session data, which is stored in thread-local storage to avoid conflicts between threads.

8. Object Pool Pattern

What it is:
The Object Pool pattern is used to manage a pool of reusable objects rather than creating and destroying objects repeatedly.
Purpose:
To manage resources efficiently by reusing objects, which is especially useful when object creation is expensive.
Key Characteristics:
- Resource management: Reuses objects from a pool, reducing the overhead of creating new ones.
- Object reuse: Provides objects from the pool when needed and returns them when done.
- Efficient resource utilization: Objects are only created once and reused.
Example:
A database connection pool where database connections are reused to avoid the overhead of establishing a new connection each time a request is made.

9. State Machine Pattern

What it is:
The State Machine pattern is used to manage state transitions in a system. It defines the various states an object can be in and the transitions between these states based on events or conditions.
Purpose:
To simplify the management of an object's state and make it easier to control transitions between different states.
Key Characteristics:
- State representation: Each state has defined behavior and conditions for transitions.
- Event-driven: State changes are driven by events or conditions.
- Clear separation of states: State behavior is encapsulated, and the object’s state is kept clear.
Example:
A traffic light controller system that changes between "Red," "Yellow," and "Green" states based on timing.

10. Backpressure Pattern

What it is:
The Backpressure pattern is used in reactive and asynchronous systems to prevent a system from being overwhelmed by an excess of incoming requests or messages.
Purpose:
To ensure that a system doesn’t fail when the load exceeds its processing capacity by applying pressure or flow control to the incoming requests.
Key Characteristics:
- Flow control: Limits the rate of incoming requests to ensure system stability.
- Prevent overload: Protects the system from being overwhelmed by excessive demands.
- Reactive behavior: Used in systems where the system responds reactively to conditions.
Example:
In a streaming service, if the server cannot process requests fast enough, it applies backpressure to limit the flow of new data from clients.

11. Repository Pattern

What it is:
The Repository pattern is used to separate the logic of retrieving data from the rest of the application, providing a collection-like interface to access the data.
Purpose:
To abstract the data access logic, enabling easier testing, maintenance, and separation of concerns.
Key Characteristics:
- Separation of concerns: Decouples data access from business logic.
- Data abstraction: Provides an interface to access data without exposing the underlying data source.
- Testability: Makes it easier to mock data sources for unit testing.
Example:
An e-commerce application where a repository class provides methods like addProduct(), findProductById(), and getAllProducts() while abstracting the actual data source, which might be a database, file system, or web service.

Design Patterns Books

Classic Design Patterns Books

Java Design Patterns
Author: Vaskaran Sarcar
Year: 2019
Summary: A practical guide to implementing classic design patterns in Java, excellent for developers looking to deepen their understanding of design patterns.
Design Patterns: A Modern Approach
Author: Vaskaran Sarcar
Year: 2017
Summary: A modern take on design patterns with real-world examples in Java, ideal for developers familiar with object-oriented programming.
Head First Design Patterns
Authors: Eric Freeman, Elisabeth Robson, Bert Bates, Kathy Sierra
Year: 2004
Summary: A beginner-friendly book with engaging visuals and real-world examples. Ideal for those new to design patterns and object-oriented programming.
Design Patterns Explained: A New Perspective on Object-Oriented Design
Authors: Alan Shalloway, James R. Trott
Year: 2004
Summary: Offers clear explanations and examples, making design patterns more accessible for beginners and developers.
The Pragmatic Programmer: Your Journey to Mastery
Authors: Andrew Hunt, David Thomas
Year: 1999
Summary: Not exclusively focused on design patterns, this book covers key principles of software development and includes useful references to design patterns in practice.
Patterns of Enterprise Application Architecture
Author: Martin Fowler
Year: 2002
Summary: Focuses on the architecture of enterprise applications, exploring patterns for building scalable, maintainable systems in large enterprises.
Design Patterns: Elements of Reusable Object-Oriented Software
Authors: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
Year: 1994
Summary: The foundational text for design patterns, introducing 23 classic patterns. A must-read for understanding object-oriented design.
Refactoring: Improving the Design of Existing Code
Author: Martin Fowler
Year: 1999
Summary: While primarily about refactoring, this book covers many design principles and patterns that are essential when improving legacy codebases.
The Design Patterns Smalltalk Companion
Authors: Richard Helm, Erich Gamma, Ralph Johnson, John Vlissides
Year: 1996
Summary: An adaptation of the GoF book for the Smalltalk programming language, showcasing how design patterns work in object-oriented systems.
Object-Oriented Design & Programming
Authors: Brad J. Cox, Doug Locke
Year: 1990
Summary: Covers object-oriented design concepts and programming in C++, exploring design patterns and the fundamentals behind them.

Advanced Design Patterns & Architecture Books

Microservices Patterns: With Examples in Java
Author: Chris Richardson
Year: 2018
Summary: Focuses on patterns for designing microservices architectures, helping developers design scalable, resilient microservices using design patterns.
Clean Architecture: A Craftsman's Guide to Software Structure and Design
Author: Robert C. Martin
Year: 2017
Summary: Teaches how to structure codebases for maintainability and scalability, with references to design patterns and principles for long-term software quality.
Building Evolutionary Architectures: Support Constant Change
Authors: Neal Ford, Rebecca Parsons, Patrick Kua
Year: 2017
Summary: Focuses on evolutionary architecture and designing systems that can adapt to change over time.
Design It!: From Programmer to Software Architect
Author: Michael Keeling
Year: 2017
Summary: Helps developers transition to software architects, teaching advanced design principles and how to apply patterns at a higher level.
Implementing Domain-Driven Design
Author: Vaughn Vernon
Year: 2013
Summary: A guide to implementing Domain-Driven Design (DDD) with concrete examples for architects and senior developers applying DDD at scale.
Software Architecture Patterns
Author: Mark Richards
Year: 2015
Summary: A guide to various software architecture patterns such as layered architecture, microservices, and event-driven architecture, with practical advice for enterprise-level system design.
Patterns of Software Design
Authors: Frank Buschmann, Regine Meunier, Hans Rohnert, Peter Sommerlad
Year: 1996
Summary: A deep exploration of software architecture patterns and how they are applied in large systems.
Domain-Driven Design: Tackling Complexity in the Heart of Software
Author: Eric Evans
Year: 2003
Summary: Teaches how to model complex software solutions and manage complexity by organizing the software around the domain.
Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions
Authors: Gregor Hohpe, Bobby Woolf
Year: 2003
Summary: Essential for architects working on enterprise-level integration projects. It explores messaging patterns for building integrated systems.
The Art of Software Architecture
Author: Stephen T. Albin
Year: 2003
Summary: Covers the principles and practices of software architecture, helping readers understand how to make architectural decisions, plan systems, and apply patterns effectively.

Top 10 System Design Books

System Design Interview: An Insider's Guide
Author: Alex Xu
Year: 2020
Summary: A comprehensive guide to acing system design interviews. Covers key concepts like scalability, reliability, load balancing, and database partitioning with real-world examples.
Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems
Author: Martin Kleppmann
Year: 2017
Summary: A must-read for building data-intensive applications, focusing on scalable, reliable, and maintainable systems with practical insights on database design, distributed systems, and more.
Building Microservices: Designing Fine-Grained Systems
Author: Sam Newman
Year: 2015
Summary: Offers valuable insights on breaking down monolithic applications into microservices and designing scalable, efficient, and maintainable systems.
Designing Distributed Systems: Patterns and Paradigms for Scalable, Reliable Services
Author: Brendan Burns
Year: 2018
Summary: Focuses on distributed systems, offering patterns and paradigms for building scalable, reliable services. Covers everything from consistency to fault tolerance.
Scalability Rules: 50 Principles for Scaling Web Sites
Authors: Martin L. Abbott, Michael T. Fisher
Year: 2011
Summary: Offers 50 principles for building scalable websites, providing practical and actionable advice for ensuring performance, scalability, and availability.
Site Reliability Engineering: How Google Runs Production Systems
Authors: Niall Richard Murphy, Betsy Beyer, Chris Jones, Jennifer Petoff
Year: 2016
Summary: Focuses on how Google designs, builds, and runs production systems that are scalable, reliable, and maintainable. Covers best practices and challenges.
The Art of Scalability: Scalable Web Architecture, Processes, and Organizations for the Modern Enterprise
Authors: Martin L. Abbott, Michael T. Fisher
Year: 2010
Summary: A detailed exploration of scalable architecture and organizations for growing enterprises, offering strategies and frameworks for managing scalability.
Cloud Native Patterns: Designing Change-Tolerant Software
Author: Cornelia Davis
Year: 2020
Summary: A guide to designing cloud-native applications that are scalable, resilient, and can easily tolerate change in a cloud environment.
Microservices Patterns: With Examples in Java
Author: Chris Richardson
Year: 2018
Summary: Focuses on building microservices using patterns and best practices, including communication, data management, security, and testing.
Designing Large-Scale Distributed Systems
Author: Brendan Burns
Year: 2021
Summary: A modern look at designing large-scale distributed systems, focusing on real-world use cases and practical solutions for scaling.

Top 10 Code Interview Books

Cracking the Coding Interview: 189 Programming Questions and Solutions
Author: Gayle Laakmann McDowell
Year: 2015
Summary: The go-to book for coding interview preparation. Contains detailed solutions to 189 questions across data structures, algorithms, and system design.
Elements of Programming Interviews: The Insiders' Guide
Authors: Adnan Aziz, Tsung-Hsien Lee, Amit Prakash
Year: 2012
Summary: Offers a collection of coding interview questions and their solutions, along with strategies for tackling interview problems effectively.
Programming Pearls
Author: Jon Bentley
Year: 2000
Summary: A classic that covers programming problems, problem-solving strategies, and optimization techniques. Great for improving logical thinking and efficiency.
The Coding Interview: A Comprehensive Guide to Interviews
Author: Raffaele Cecco
Year: 2020
Summary: Provides a complete guide to mastering coding interviews with over 100 questions, solutions, and a breakdown of the interview process.
The Algorithm Design Manual
Author: Steven S. Skiena
Year: 2009
Summary: A fantastic resource for understanding algorithms and how to design them. Includes numerous problems to practice solving real-world challenges.
LeetCode 101: A Beginner's Guide to Programming Interview Problems
Author: LeetCode
Year: 2020
Summary: Offers easy-to-understand solutions to LeetCode problems, breaking down the logic behind common coding interview questions.
The Pragmatic Programmer: Your Journey to Mastery
Authors: Andrew Hunt, David Thomas
Year: 1999
Summary: A well-known programming book that provides valuable lessons on software craftsmanship, coding principles, and problem-solving strategies.
Interviewing for Technical Jobs
Author: Nisha Talagala
Year: 2021
Summary: A comprehensive guide to technical job interviews with a focus on problem-solving, coding challenges, and system design.
LeetCode Patterns for Coding Interviews
Author: Owais Iqbal
Year: 2021
Summary: Focuses on the most common coding patterns asked in interviews, using LeetCode-style problems and solutions.
Coding Interviews: 100+ Solutions to the Most Commonly Asked Interview Questions
Author: Interviewing.io
Year: 2020
Summary: A collection of 100+ coding problems and detailed solutions, with a focus on helping candidates improve their coding and interview skills.

Name		Name	Last commit message	Last commit date
Latest commit History 20 Commits
api-abstract-factory-gui-framework		api-abstract-factory-gui-framework
api-factory-method-document-generation		api-factory-method-document-generation
api-factory-method-payment		api-factory-method-payment
api-factory-method		api-factory-method
api-singleton-logger		api-singleton-logger
.gitignore		.gitignore
README.md		README.md

klintfox/design-patterns

Folders and files

Latest commit

History

Repository files navigation