What is the scope of the Single Responsibility Principle? [closed]

by

Bob Martin has tried to clear this up on multiple occasions. The problem is that there are two different principles in play here; and it’s extremely unfortunate that one of them doesn’t really have a name, which is why it’s commonly conflated with the SRP.

Functions should do one thing. They should do it well. They should do it only. –Clean Code (page 35)

That section of the book is simply titled, “Do One Thing” but it is not talking about the SRP. Martin makes this even more clear in his next book.

A function should do one, and only one, thing. We use that principle when we are refactoring… at the lowest levels. But it is not one of the SOLID principles–it is not the SRP. –Clean Architecture (page 62)

The best online explanation of the SRP is Martin’s blog, which is summarized in the tag wiki. In the blog, and in his books, Martin is (fairly) consistent in using the term module to describe the scope in which the SRP applies. A module is simply a source file, and that usually just means a class file.

A module should be responsible to one, and only one, actor.

More Related Contents:

  1. What is an example of the Single Responsibility Principle? [closed]
  2. Does the Single Responsibility Principle work in OOP?
  3. In SOLID, what is the distinction between SRP and ISP? (Single Responsibility Principle and Interface Segregation Principle)
  4. What is an example of the Liskov Substitution Principle?
  5. What is the dependency inversion principle and why is it important?
  6. What is the meaning and reasoning behind the Open/Closed Principle?
  7. Interface Segregation Principle- Program to an interface
  8. Are there any rules for OOP?
  9. Can’t seem to understand SOLID principles and design patterns [closed]
  10. Why doesn’t Rust support trait object upcasting?
  11. Inheritance vs. Aggregation [closed]
  12. Constructors vs Factory Methods [closed]
  13. Why would I want to use Interfaces? [closed]
  14. When should one use interfaces?
  15. What is the difference between an abstract method and a virtual method?
  16. What is the rationale behind having companion objects in Scala?
  17. What is the difference between aggregation, composition and dependency? [duplicate]
  18. Do write-only properties have practical applications?
  19. Polymorphism – Define In Just Two Sentences [closed]
  20. DDD – the rule that Entities can’t access Repositories directly
  21. Are Polymorphism , Overloading and Overriding similar concepts? [closed]
  22. If-less programming (basically without conditionals) [closed]
  23. Can you explain Liskov Substitution Principle with a good C# example? [closed]
  24. When to implement an interface and when to extend a superclass?
  25. Mixin vs inheritance
  26. What does ‘low in coupling and high in cohesion’ mean
  27. Learning/Implementing Design Patterns (For Newbies) [closed]
  28. When to use a Class in VBA?
  29. VBA: how to test for object equality (whether two variables reference the same object)
  30. Overloading functions

Leave a Comment