The document outlines the SOLID software design principles: Single Responsibility Principle (SRP), Open/Closed Principle (OCP), Liskov Substitution Principle (LSP), Interface Segregation Principle (ISP), and Dependency Inversion Principle (DIP). These principles emphasize the importance of modularity, code extension, and minimizing dependencies while also advocating for simplicity and refraining from unnecessary implementation. Additional principles mentioned include DRY (Don't Repeat Yourself), KISS (Keep It Simple, Stupid), and YAGNI (You Ain't Gonna Need It).

1. SOFTWARE DESIGN
PRINCIPLES
- (SOLID)

2. • Single Responsibility Principle (SRP)
• Open/Closed Principle (OCP)
• Liskov Substitution Principle (LSP)
• Interface Segregation Principle (ISP)
• Dependency Inversion Principle (DIP)
SOLID

3. • A class | A module | A function should have;
• Only ONE purpose
• A class methods and properties should have same goal
• For different properties and different jobs, export them
to another class
Single Responsibility Principle (SRP)

4. A class should have one, and only one,
reason to change.
Do one thing and do it well.

5. Single Responsibility Principle (SRP)

6. Gather together the things that change for the
same reasons.
Separate those things that change for different
reasons.

7. • A class | A module | A function should be;
• Open for extension
• Close for modification.
• Add new functionality without changing existing code
• A change to sub-class shall not need a change on parent
Open/Closed Principle (OCP)

8. Software entities (classes, modules,
functions, etc.) should be open for
extension, but closed for modification.

9. Open/Closed Principle (OCP)

10. We should strive to write a code that
doesn’t have to be changed every time
requirements changed.

11. • Parent classes should be easily substituted with their
child class.
• The code should still work.
Liskov Substitution Principle (LSP)

12. Objects in a program should be replaceable
with instances of their subtypes without
altering the correctness of that program.

13. Liskov Substitution Principle (LSP)

15. Interface SegregationPrinciple (ISP)
• No child class should be forced to implement not used
methods.
• Split large interfaces into smaller ones
• Split general interfaces into more specific ones

16. Many client specific interfaces are better
than one general interface.

17. Interface SegregationPrinciple (ISP)

18. A Client should not be forced to implement
an interface that it doesn’t use.

19. Dependency Inversion Principle (DIP)
• 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.

20. Depend on Abstractions not on concretions.

21. Dependency Inversion Principle (DIP)

22. • Single Responsibility Principle (SRP)
• Open/Closed Principle (OCP)
• Liskov Substitution Principle (LSP)
• Interface Segregation Principle (ISP)
• Dependency Inversion Principle (DIP)
SOLID

23. • DRY (Don’t Repeat Yourself)
• Each small piece of code may only occur once
• KISS (Keep it simple, Stupid!)
• Piece of software code should be kept simple
• YAGNI (You ain’t gonna need it)
• Never implement a thing before you need them
OTHERDESIGN PRINCIPLES

24. THANKS
Muhammed Asım YILDIZ