Suggest an editImprove this articleRefine the answer for “Why are "fat" interfaces harmful?”. Your changes go to moderation before they’re published.Approval requiredContentWhat you’re changing🇺🇸EN🇺🇦UAPreviewTitle (EN)Short answer (EN)**"Fat" interfaces** are harmful because they create unnecessary dependencies and make a system fragile, hard to extend, and poorly testable. **Key point:** fat interfaces are harmful because they increase coupling, complicate maintenance, require extra code, create cascades of changes, and make the system fragile.Shown above the full answer for quick recall.Answer (EN)Image"Fat" interfaces are harmful because they create unnecessary dependencies and make a system fragile, hard to extend, and poorly testable. In detail: ### 1. Clients depend on methods they do not need If an interface contains 10 methods and a client uses only 1-2 of them, it is forced to depend on all ten. Any change to those methods affects the client, even though it is functionally unrelated to them. This increases coupling and breaks the stability of the system. ### 2. Implementations are forced to support unneeded behavior A class that implements a "fat" interface must implement methods it does not need. Often those methods are either empty or stubs - a direct sign of an ISP violation. Such code is hard to maintain and test, because part of its behavior is meaningless. ### 3. Interface changes cause mass changes across the code If a new method is added to a large interface, every implementation is required to implement it. Even the ones that do not need it at all. This creates a cascade of changes across the whole system. ### 4. Reusability decreases A fat interface is hard to reuse - it is tied to too large a set of methods. Such an API becomes inflexible and overloaded. ### 5. Individual modules become harder to test When an interface contains a dozen methods, the object under test either: - requires a large number of mocks, - or the tests are forced to account for methods unrelated to the test scenario. This complicates and overloads the test environment. ### 6. The Single Responsibility Principle (SRP) is violated A fat interface almost always contains methods that belong to different areas of responsibility. This leads to confusion and unpredictable behavior. Summary: **Fat interfaces are harmful because they increase coupling, complicate maintenance, require extra code, create cascades of changes, and make the system fragile. The ISP prevents these problems by forcing interfaces to be small and specific.**For the reviewerNote to the moderator (optional)Visible only to the moderator. Helps review go faster.