General Overview

The so called SOLID Principles are a set of design principles aimed at making the software more maintainable, understandable, and flexible. These principles were proposed to improve the code quality, making it easier to read and less complex, in the object-oriented programming paradigm. These principles make arguments for how the code should be split up, which parts should be internal or exposed, how code should use other code, etc. Although these principles were specifically designed for the OOP paradigm, adhering to these can be specially helpful in other paradigms like Functional programming. They are best used when rather that being thought of as a requirement are kept in mind as a general guide on how to structure the code, so as to make it easier to understand further down the line.

What does SOLID stand for?

Well SOLID is an acronym referring to 5 design principles namely

• S - Single Responsibility Principle

  • Original : There should never be more than one reason for a class to change

  • New : Each module should do one thing and do it well

• O - Open Closed Principle

  • Original : Software entries should be open for extension, but closed for modification

  • New : You should be able to use and add to a module without rewriting it

• L - Liskov Substitution Principle

  • Original : If S is a sub type of T, then objects of type T may be replaced with objects of type S without altering any of the desirable properties of the program

  • New : You should be able to substitute one thing for another if those things are declared to behave the same way

• I - Interface Segregation Principle

  • Original : Many client-specific interfaces are better than one general-purpose interface

  • New : Don't show your clients more than they need to see

• D - Dependency Inversion Principle

  • Original : Depend upon abstractions, not concretions

  • New : Depend upon abstractions, not concretions

The original definition above, refers to the original interpretation of the respective design principles which is in a sense severely limited by its use only in the OOP paradigm. The new definitions here, are taken from the "Stack Overflow Blog" and highlight the use of these principles in more general situations and other programming paradigms.

Conclusion

The SOLID principles are a general guideline on how to write "cleaner" code, which focuses on code re usability, easier understanding, and reduced complexity. These principles stem for the fact that code has always been written by humans and is always read more times than it is being written or modified. Same will be the most probable case for the foreseeable future, hence these principles indirectly or directly drive programmers to write easily maintainable and understandable code.