The document outlines key concepts and principles of software design patterns, highlighting their importance in addressing common design problems. It discusses fundamental object-oriented programming principles such as DRY, single responsibility, and open-closed principles, which promote maintainable and reusable code. Additionally, it describes several design patterns, including strategic patterns, adapter, factory, and singleton, providing an overview of their purposes and benefits.

1. Design Patterns 101

2. $ whoami
Ritesh Agrawal
udr.ritesh@gmail.com
Software Engineer at Cyware Labs
https://www.linkedin.com/in/riteshagrawal18/

3. Considerations during Software Design
● Changing requirement/Feature Extension
● Technology changes
● Reusability
● Reduce Impact of code change

4. What is Design Pattern?
● Solution for the common software design problem
● It is a concept not implementation
● Technology independent

5. How?

6. Basics of OOP
● Abstraction
● Encapsulation
● Inheritance
● Polymorphism

7. Design Principles

8. Do Not Repeat Yourself (DRY)
● Aimed at reducing repetition of code
● Use of helper classes and utilities

9. Single Responsibility Principle
● Class, module or function should have single responsibility
● High Cohesiveness
● Single Reason of change

10. Open-Close Principle
● Software entities (classes, modules, functions, etc.) should be open for
extension, but closed for modification.
● Classes allow to subclass and alter the behaviour but not allowed to change
the existing code

11. Program to Interfaces, not Implementations
● Focus on what to be done rather than how
● Interact at more abstract level
● Helps in changing the details without affecting the client or caller

12. Encapsulate What Varies
● Change is the only constant
● Isolate the implementation details which changes frequently
● Can be business logic, library, interface, etc.
● Legacy code handling

13. Design Patterns

14. Strategic Pattern
● This pattern allows usage of different strategies by encapsulating the
algorithm
● Algorithm can vary independent of the client
● Client knows about the interface but not implementation

15. Adapter
● Joins functionality of incompatible interface
● Generalize interface of other functionality which can be helpful to change it in
future
● Using different product, libraries

16. Factory
● Abstracts process of creational of new objects
● Reduces code coupling by abstracting details of concrete classes

17. Singleton
● Restricts creation of one object per class
● Helpful in creating db connection objects

18. Question/Feedback ?

19. Thanks