SOLID explained

In software programming, SOLID is a mnemonic acronym for five design principles intended to make object-oriented designs more understandable, flexible, and maintainable. Although the SOLID principles apply to any object-oriented design, they can also form a core philosophy for methodologies such as agile development or adaptive software development.

Principles

Single responsibility principle

Single-responsibility principle (SRP) states that "[t]here should never be more than one reason for a class to change."^[1] In other words, every class should have only one responsibility.^[2]

Importance

• Maintainability: When classes have a single, well-defined responsibility, they're easier to understand and modify.
• Testability: It's easier to write unit tests for classes with a single focus.
• Flexibility: Changes to one responsibility don't affect unrelated parts of the system.

Open–closed principle

Open–closed principle (OCP) states that "[s]oftware entities ... should be open for extension, but closed for modification."^[3]

Importance

• Extensibility: New features can be added without modifying existing code.
• Stability: Reduces the risk of introducing bugs when making changes.
• Flexibility: Adapts to changing requirements more easily.

Liskov substitution principle

Liskov substitution principle (LSP) states that "[f]unctions that use pointers or references to base classes must be able to use objects of derived classes without knowing it."^[4]

Importance

• Polymorphism: Enables the use of polymorphic behavior, making code more flexible and reusable.
• Reliability: Ensures that subclasses adhere to the contract defined by the superclass.
• Predictability: Guarantees that replacing a superclass object with a subclass object won't break the program.

Interface segregation principle

Interface segregation principle (ISP) states that "[c]lients should not be forced to depend upon interfaces that they do not use."^[5]

Importance

• Decoupling: Reduces dependencies between classes, making the code more modular and maintainable.
• Flexibility: Allows for more targeted implementations of interfaces.
• Avoids unnecessary dependencies: Clients don't have to depend on methods they don't use.

Dependency inversion principle

Dependency inversion principle (DIP) states to depend upon abstractions, [not] concretes.^[6]

Importance

• Loose coupling: Reduces dependencies between modules, making the code more flexible and easier to test.
• Flexibility: Enables changes to implementations without affecting clients.
• Maintainability: Makes code easier to understand and modify.

Origin

Software engineer and instructor, Robert C. Martin,^{[7] [8] [9]} introduced the collection of principles in his 2000 paper Design Principles and Design Patterns about software rot.^[10] The SOLID acronym was coined around 2004 by Michael Feathers.^[11]

See also

• Code reuse
• GRASP (object-oriented design)
• Inheritance (object-oriented programming)
• List of software development philosophies

Notes and References

1. Web site: Single Responsibility Principle. usurped. https://web.archive.org/web/20150202200348/http://www.objectmentor.com/resources/articles/srp.pdf. 2 February 2015. objectmentor.com.
2. Book: Robert Cecil Martin

   . Martin. Robert C.. Agile Software Development, Principles, Patterns, and Practices. Prentice Hall. 2003. 978-0135974445. 95. Robert Cecil Martin.

3. Web site: Open/Closed Principle. usurped. https://web.archive.org/web/20150905081105/http://www.objectmentor.com/resources/articles/ocp.pdf. 5 September 2015. objectmentor.com.
4. Web site: Liskov Substitution Principle. usurped. https://web.archive.org/web/20150905081111/http://www.objectmentor.com/resources/articles/lsp.pdf. 5 September 2015. objectmentor.com.
5. Web site: 1996. Interface Segregation Principle. usurped. https://web.archive.org/web/20150905081110/http://www.objectmentor.com/resources/articles/isp.pdf. 5 September 2015. objectmentor.com.
6. Web site: Dependency Inversion Principle. usurped. https://web.archive.org/web/20150905081103/http://www.objectmentor.com/resources/articles/dip.pdf. 5 September 2015. objectmentor.com.
7. Web site: Martin . Robert C. . Robert C. Martin . Principles Of OOD . live . https://web.archive.org/web/20140910201842/http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod . Sep 10, 2014 . 2014-07-17 . ButUncleBob.com. . (Note the reference to "the first five principles", although the acronym is not used in this article.) Dates back to at least 2003.
8. Web site: Martin . Robert C. . 13 Feb 2009 . Getting a SOLID start . live . https://web.archive.org/web/20130917122741/https://sites.google.com/site/unclebobconsultingllc/getting-a-solid-start . Sep 17, 2013 . 2013-08-19 . Uncle Bob Consulting LLC (Google Sites).
9. Web site: Metz . Sandi . Sandi Metz . May 2009 . SOLID Object-Oriented Design . live . https://ghostarchive.org/varchive/youtube/20211221/v-2yFMzxqwU . 2021-12-21 . 2019-08-13 . YouTube. Talk given at the 2009 Gotham Ruby Conference.
10. Web site: Martin, Robert C. . 2000 . Design Principles and Design Patterns . usurped . https://web.archive.org/web/20150906155800/http://www.objectmentor.com/resources/articles/Principles_and_Patterns.pdf . 2015-09-06 . objectmentor.com.
11. Book: Martin, Robert . Clean Architecture: A Craftsman's Guide to Software Structure and Design . Pearson . 2018 . 978-0-13-449416-6 . 58.