This is the 11th article on the System Design and Software Architecture series. In this article, we are discussing the sub-topic of the design principle, ISP : Interface Segregation Principle.
Previous articles
- Introduction to System Design and Architecture
- Values of system software
- Programming Paradigm
- Object-Oriented Programming
- Structured programming
- Functional programming
What is The Interface Segregation Principle?
The interface Segregation principle states that clients should not force to run interfaces that they do not use. Instead of an individual huge interface, many smaller interfaces are more optimal based on the methodology, each serving one sub-module.
ISP divides interfaces that are very large into smaller and more specialized interfaces so that clients want to execute only the methods that interest them.
The purpose of ISP is to facilitate the disassembly and reactivation, modification, and re-deployment of a system. Because a system is connected at different levels, changes cannot be made in one place without the need for any additional changes. These side effects can prevent by using an interface or an abstract class.
The purpose of ISP is to facilitate the disassembly and reactivation, modification, and re-deployment of a system. Because a system is connected at different levels changes have no ability to make in one place without the need for any additional changes. These side effects have the ability to prevent by using an interface or an abstract class.
An accurate summary is a key to the interface separation principle
Finding the right summaries is more than just an art. Of course, you have to explore your domain, often create interpretation nets, and submit user series. Also, draw interactive diagrams – all of which do not lead you to correct abstractions. Wrong abstractions are worse than abstractions at all, so do not forget about the third rule.
When you think you are done with some of your abstractions, portray them as interfaces. The techniques mentioned above make them a terrestrial interface. With this approach, concrete classes function only to the extent necessary for those abstractions. So we end up with satisfaction without knowing that the interface separation principle exists.
Violation of Interface Segregation Principle
When the client relies on methods that do not use it. It means that your abstraction is wrong. Martin Fowler’s Role Example of an Interface (which is a natural encyclopedia of ISP applications) reveals incorrect initial object decomposition. It does not take an independent policy to express it. The code is clearly not compact. So do not meditate on whether your code violates the principle of interface separation, think about whether your summaries are correct.
Importance
In object-oriented design, the code simplifies and creates abstract layer interfaces that create a barrier that prevents it from interacting with dependencies.
According to many software experts who have signed the Policy Statement for Software Technology. Also writing well-designed and self-explanatory software is as important as writing working software. It is often a good idea to use interfaces to further explain the intent of the software.
Because a system is connected on multiple levels, no change can be made in one place without the need for any additional changes. These side effects have the ability to prevent by using an interface or an abstract class.
Code or codes for ISP violation and how to fix them
Whether working alone or in large groups, it helps to identify problems with the code in advance. Therefore, let us discuss some of the code orders that can indicate an ISP infringement loan.
Great interface
In large interfaces, there are too many operations, but for most objects, these operations are not used. ISP tells us that we need most or all of the methods in an interface and in a large interface we often need only a few of them. Also, when testing a large interface, we need to identify which dependencies should need to be mocked and which may have a giant test setup.
Unused Dependencies
Another implication of ISP breach of credit is that we must give a system a value of zero or equivalent. In our example, we can use Odercombo () to place a burger-only order bypassing zero as the fries parameter. This client does not need to depend on fries, so we must have a separate interface for ordering fries.
Exceptional throwing methods
As in our burger example, if we encounter a non-operational exception. And Not Implemented Exception or similar exception, it may feel like an ISP-related design problem. This can make a good time to redesign these classes.
So, should interfaces always have a single method?
Application to the ISP end also results in a single-mode interface known as an interface.
This solution will solve the problem of ISP breach of debt. However, it cans also a violation of the coherence of interfaces. And making it difficult to maintain a scattered code base as a result. For example, in Java, the add-on interface has many modes, such as size () and is Empty (), which are often used together, so it makes sense to have a single interface.
Benefits
ISP is the reduction of code objects to their smallest execution and the removal of dependencies that are not required for the object to function properly. The effect of implementing this principle, in general, is to have a number of small, centralized interfaces that only define what is needed to implement them.
Is it worth it?
Sometimes it is worth it. This is the only SOLID principle. On the one hand, by following this principle aggressively you can get a more flexible and changeable code, I am a big fan and it is very useful for real-world projects.
Conclusion
ISP is a straightforward principle that is easy to override by gradually adding to existing interfaces that clients that do not need. ISP is also closely related to other SOLID principles.
There are much code smells that can help us identify and correct ISP violations. However, we need to keep in mind that over-aggressive implementation of any principle can lead to other problems in the codebase.
LSP taught us why reality cannot be represented as a one-on-one relationship with programmed objects. And how subcategories respect their parents. Let us also consider other principles that we already know.
ISP teaches us to respect our clients more than we thought. Respecting their needs makes our code better and makes our lives easier as programmers.
Thanks for reading the article ISP: The Interface Segregation Principle as an essential component in System design and architecture.
My articles on medium
