This article is partially based on R Martin's book, Clean Architecture(2017) and describes some of the core principles for designing software architecture.
The SOLID principles tell us how to arrange our functions and data structures into classes, and how those classes should be interconnected. The goal of the principles is the creation of mid-level software that:
-Are easy to undersand,
-Are the basis of components that can be used in many software systems
The term mid-level refers to the fact that this principles are applied by programmers working at the module level. They are applied just above the level of code and help to define the kinds of software structures used within modules and components.
The SOLID principles are:
-SRP: The Single Responsibility Principle
The best software system is heavily influenced by the social structure of the organization that uses it so that each software module has one, and only one, reason for change.
-OCP: The Open-Closed Principle
The best software system is easy to change by adding new code, rather than changing existing code.
-LSP: The Liskov Substitution Principle
This Principle from Barbara Liskov(1988) says that to build software from interchangeable parts, those parts must adhere to a contract that allows those parts to be substituted one for another.
-ISP: The Interface Segregation Principle
This principle advises software designers to avoid depending on things that they don't use.
-DIP: The Dependency Inversion Principle
The code that implements high-level details should not depend on the code that implements low-level details. Rather, details should depend on policies.
SOLID software architecture design