Software Dev/01 - Design Patterns in Software Development.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Design Patterns in Software Development\n",
    "\n",
    "## Definition\n",
    "As defined in [Intro](<../00 - Intro.ipynb>) design patterns in software development provide guidance and best practices for structuring code, organizing classes and objects, and managing relationships between them. They help improve code organization, quality, maintainability, and extensibility, as well as promote code reusability and software design principles such as encapsulation, loose coupling and separation of concerns, and make software systems more scalable and flexible.\n",
    "\n",
    "> This notebook page will be used to explain theoretical concepts about design patterns in software dev. For code examples, go to the following pages of each design pattern in this folder.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why you should use design patterns in software development\n",
    "- Reusability: Design patterns encapsulate proven solutions to recurring design problems. By using design patterns, you can leverage the knowledge and experience of experts, saving time and effort in solving similar problems in different contexts. Design patterns provide reusable components that can be applied to different projects.\n",
    "\n",
    "- Maintainability: Design patterns promote clean and organized code structures, making software systems easier to understand and maintain. Patterns provide a common language and structure that enable developers to communicate and collaborate effectively. The use of design patterns enhances code readability, reduces complexity, and improves the overall maintainability of the software.\n",
    "\n",
    "- Scalability and Flexibility: Design patterns enable software systems to scale and adapt to changing requirements and evolving technologies. Patterns provide flexible and extensible designs that can accommodate future enhancements and modifications. By following established patterns, you can build systems that are easier to extend, modify, and customize without introducing significant architectural changes.\n",
    "\n",
    "- Best Practices: Design patterns embody best practices and principles of software design. They capture the collective wisdom of experienced developers and architects. By using design patterns, you can align your code with industry standards, proven techniques, and established guidelines. Patterns help in creating robust, efficient, and high-quality software systems.\n",
    "\n",
    "- Communication and Collaboration: Design patterns provide a common vocabulary and conceptual framework for discussing and documenting software designs. They facilitate communication and collaboration among developers, architects, and stakeholders. Design patterns serve as a bridge between software design concepts and their practical implementation.\n",
    "\n",
    "- Problem Solving: Design patterns offer effective solutions to common design problems in a specific context. They provide well-tested approaches to address specific concerns, such as object creation, behavior encapsulation, code organization, or system interaction. By utilizing patterns, you can solve design challenges efficiently and effectively, reducing the risk of introducing design flaws or reinventing the wheel.\n",
    "\n",
    "> Overall, design patterns provide a proven and systematic approach to software design. They promote code reuse, maintainability, scalability, and adherence to best practices. By utilizing design patterns, you can enhance the quality, flexibility, and maintainability of your software systems while reducing development time and effort.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Categories\n",
    "There are three categories of software design patterns: creational patterns, structural patterns, and behavioral patterns. Each category addresses a specific set of design concerns. Creational patterns deal with object creation mechanisms, structural patterns address the composition of classes and objects, and behavioral patterns capture the interaction and distribution of responsibilities among classes and objects.\n",
    "\n",
    "## Creational Patterns\n",
    "Creational patterns deal with object creation mechanisms. They encapsulate the knowledge about which concrete classes the system uses. This information is hidden from the client and is localized in the pattern implementation. Creational patterns help make a system independent of how its objects are created, composed, and represented. They encapsulate knowledge about the concrete classes used by the system and hide this knowledge from the client. They provide a level of indirection between the client and the objects, which reduces the coupling between them. This indirection gives more flexibility in the way objects are created, composed, and represented.\n",
    "\n",
    "Examples of creational patterns include:\n",
    "- [Singleton](<02 - Singleton.ipynb>): Ensures that only one instance of a class is created and provides a global point of access to it.\n",
    "- [Factory Method](<03 - Factory Method.ipynb>): Defines an interface for creating objects, but allows subclasses to decide which class to instantiate.\n",
    "- [Builder](<04 - Builder.ipynb>): Separates the construction of complex objects from their representation, allowing the same construction process to create different representations.\n",
    "- [Prototype](<05 - Prototype.ipynb>): Allows an object to create copies of itself, providing an interface to specify the kind of object to create using a prototypical instance, and creating new objects by copying this prototype.\n",
    "- [Abstract Factory](<06 - Abstract Factory.ipynb>): Provides an interface for creating families of related or dependent objects without specifying their concrete classes.\n",
    "\n",
    "## Structural Patterns\n",
    "Structural patterns address the composition of classes and objects. They help form large object structures while keeping them flexible and efficient. Structural patterns help make a system independent of how its classes and objects are composed, structured, and represented. They provide a level of indirection between the client and the objects, which reduces the coupling between them. This indirection gives more flexibility in the way objects are composed, structured, and represented.\n",
    "\n",
    "Examples of structural patterns include:\n",
    "- [Adapter](<07 - Adapter.ipynb>): Converts the interface of a class into another interface that clients expect, allowing incompatible classes to work together.\n",
    "- [Decorator](<08 - Decorator.ipynb>): Dynamically adds new behavior to an object by wrapping it with a new object that provides the same interface.\n",
    "- [Composite](<09 - Composite.ipynb>): Composes objects into tree-like structures to represent part-whole hierarchies. Clients can treat individual objects and compositions uniformly.\n",
    "- [Proxy](<10 - Proxy.ipynb>): Provides a surrogate or placeholder for another object to control access to it or add additional behavior.\n",
    "\n",
    "## Behavioral Patterns\n",
    "Behavioral patterns capture the interaction and distribution of responsibilities among classes and objects. They help define communication between classes and objects, making them more flexible and reusable. Behavioral patterns help make a system independent of how its classes and objects communicate and distribute responsibilities. They provide a level of indirection between the client and the objects, which reduces the coupling between them. This indirection gives more flexibility in the way objects communicate and distribute responsibilities.\n",
    "\n",
    "Examples of behavioral patterns include:\n",
    "- [Observer](<11 - Observer.ipynb>): Defines a one-to-many dependency between objects, so that when one object changes state, all its dependents are notified and updated automatically.\n",
    "- [Strategy](<12 - Strategy.ipynb>): Defines a family of interchangeable algorithms and encapsulates each one, allowing them to be selected and used at runtime.\n",
    "- [Command](<13 - Command.ipynb>): Encapsulates a request as an object, thereby allowing parameterization of clients with different requests, queueing, or logging of requests, and supporting undoable operations.\n",
    "- [Template Method](<14 - Template Method.ipynb>): Defines the skeleton of an algorithm in a method, deferring certain steps to subclasses.\n",
    "- [Iterator](<15 - Iterator.ipynb>): Provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation.\n",
    "- [State](<16 - State.ipynb>): Allows an object to alter its behavior when its internal state changes, so that the object appears to change its class.\n",
    "\n",
    "These are the most commonly used design patterns in software dev. There are many other design patterns that are not covered in this notebook. For a complete list of design patterns, see [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612) by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides (also known as the Gang of Four or GoF).\n",
    "\n",
    "## Summary\n",
    "The following table summarizes the categories of design patterns, their intent, and examples of each category.\n",
    "\n",
    "> In the following pages, each design pattern of this summary will be explained in detail, with code examples in C#.\n",
    "\n",
    "| Category | Intent | Examples |\n",
    "| :---: | :---: | :---: |\n",
    "| Creational | Deals with object creation mechanisms | Singleton, Factory Method, Builder, Prototype, Abstract Factory |\n",
    "| Structural | Deals with the composition of classes and objects | Adapter, Decorator, Composite, Proxy |\n",
    "| Behavioral | Deals with the interaction and distribution of responsibilities among classes and objects | Observer, Strategy, Command, Template Method, Iterator, State |"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}