SRP tells us that you should only have a single responsibility in a module. ISP tells us that you should not be forced to be confronted with more than you actually need. If you want to use a print() method from interface I, you shouldn’t have to instantiate a SwimmingPool or a DriveThru class for … Read more
I like to state the single responsibility principle this way: “Every thing you write — every module, class, interface, or method, should have one job. It should do the whole job and only that job. Notice that some of these things you write are big (modules), some are small (methods), some are in between (classes), … Read more
The most effective way to break applications is to create GOD classes. Those are classes that keep track of a lot of information and have several responsibilities. One code change will most likely affect other parts of the class and therefore indirectly all other classes that use it. That in turn leads to an even … Read more
Let’s start with what does Single Responsibility Principle (SRP) actually mean: A class should have only one reason to change. This effectively means every object (class) should have a single responsibility, if a class has more than one responsibility these responsibilities become coupled and cannot be executed independently, i.e. changes in one can affect or … Read more
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. … Read more