Design Principles

• Design patterns provide reusable solutions to common problems.
• They began as best practices applied repeatedly to similar issues.
• The goal is to avoid rigidity, fragility, and immobility in design.

SOLID Principles

• These design principles aim to reduce dependencies
• They intend to promote modularity and maintainability

Single Responsibility Principle

• Each class should have only one reason to change.
• Poor design results in one change affecting the entire class and clients.
• Good design separates responsibilities, so a change affects only one class.

Open/Close Principle

• Software entities should be open for extension but closed for modifications.
• Extension utilizes abstract and concrete classes.
• Compatibility is important in design.

Liskov's Substitution Principle

• Derived types must be completely substitutable for their base types.
• Clients should not need to know implementation details.
• A square is a rectangle, but not every rectangle is a square

Interface Segregation

• Clients should not be forced to depend on interfaces they don't use.
• A too large interface should be split to multiple, smaller specific interfaces.

Dependency Inversion

• High-level modules should not depend on low-level modules.
• Both should depend on abstractions.
• Abstractions should not depend on details.
• Details should depend on abstractions.

Design Pattern Categories

• Creational: Focuses on object creation mechanisms.
• Behavioral: Deals with interaction and responsibility assignment between objects.
• Structural: Focuses on easing relationships between classes.

Creational Patterns

• Deal with object creation, selecting the most suitable method for the situation.

Singleton

• This ensures that only one instance of a class is created.
• It provides a global point of access to the object.
• Loggers, configurations, and multithreading often use this pattern.

Factory

• Factory creates objects without exposing the instantiation logic to the client.
• The created object is referenced through a common interface.

Builder

• Use builder for creating an object, yet let subclasses decide which class to instantiate.
• It delivers the newly created object with the help of an interface.
• It is useful for vehicle manufacturers and exam access control.

Prototype

• Specifies the kind of objects to create using a prototypical instance.
• Creates new objects by copying this prototype.
• It can be quicker to edit a clone than create original.

Object Pool

• Object pools reuse and share objects that are expensive to create.
• Can be used for threads, network connections and limited memory.

Behavioral Patterns

• Behavioral patterns facilitate interaction between loose coupled classes and objects.
• These patterns address responsibility assignments between objects.

Classifications

• Task Delegation
• Algorithm Delegation
• State Management
• Communication Management
• Traversing Patterns

Chain of Responsibility

• Provides ordered receivers with the handler object
• Each instance decides either to process the request or pass it to next receiver in the chain.
• Common use includes network requests, shipping requests and GUI classes.

Command

• Encapsulates a request as an object, thereby letting parameterize clients with different requests
• Uses queuing or logging requests, and support undoable operations.
• Stock and food orders are implemented using this pattern.

Interpreter

• Creates a tree structure which represents the grammar of a language
• Utilizes an interpreter to evaluate the language expression
• Python, Ruby and Javascript are examples.

Iterator

• Accesses the elements of an aggregate object sequentially without exposing its underlying structure.
• Examples include arrays, linked lists, queues and stacks.

Mediator

• Used to reduce coupling between classes that communicate with each other directly
• Forces objects to communicate through a mediator object, instead of directly.
• Common in chat applications and GUI libraries.

Memento

• Captures and externalizes an object's internal state so that the object can be restored to this state later.
• Used for error handeling, undo operations and database transactions.

Observer

• Defines a one-to-many dependency between objects
• When one object changes state, all its dependents are notified and updated automatically.
• Usefull for automated emails and event handlers.

Strategy

• Defines a family of algorithms, encapsulates each one, and makes them interchangeable.
• Strategy lets the algorithm vary independently from clients that use it.
• Can be used in automated robots and game AI.

Template Method

• Defines the skeleton of an algorithm in an abstract class.
• Lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.
• It is useful to take trips from place to place

Visitor

• Used to separate algorithms from their objects.
• Also handles algorithms and sorting algos.

Null Object

• Provides the means for doing “nothing”.
• Used to provide the functionality of a placeholder.

Structural Patterns

• Structural patterns focus improving relationships between classes.
• They simplify structures through identification of relationships.

Adapter

• Allows the interface of an existing class to be used as another interface.
• Commonly used for power adapters, card readers, software frameworks and 3rd party libraries.

Bridge

• Decouples an abstraction from its implementation so that the two can vary independently.
• Supports libraries independent of Operating System and databases.

Composite

• Composes objects into tree structures, supporting part-whole hierarchies.
• Clients treat individual objects and compositions uniformly.
• Examples are web components and multiselect widgets.

Decorator

• Decorates objects with additional code/functionality and additional state, dynamically adding the behavior.
• Example GUI frameworks make use of this pattern.

Flyweight

• Flyweight supports fine-grained classes efficiently.
• Flyweights achieve this through using the principle of memory optimization.
• Separate Intrinsic from Extrinsic

Proxy

• Proxy provides a placeholder for another object to control access to it.
• Common use it in Servers.

Explore SOLID design principles: Single Responsibility, Open/Closed and Liskov's Substitution. Understand how these principles promote modularity and maintainability. Improve code design by reducing dependencies and ensuring substitutability.