Programming for future use of interfaces
I have a colleague sitting next to me who designed an interface like this:
Programming for future use of interfaces
I have a colleague sitting next to me who designed an interface like this:
Programming for future use of interfaces
I have a colleague sitting next to me who designed an interface like this:
Programming for future use of interfaces
I have a colleague sitting next to me who designed an interface like this:
Programming for future use of interfaces
I have a colleague sitting next to me who designed an interface like this:
Why not apply Interface Segregation Principle to “extreme”
Providing that clients would typically consume just one method, though methods would be conceptually related, why not always apply the Interface Segregation Principle to the extreme and have [many] single-method interfaces? Is there an objective rule against this? Not something like “oh it feels wrong” or “but you will have so many types, it’s hard to read and manage” but rather something logical and clear. (Still want to name contracts clearly, so functions are not a good fit?).
Why not apply Interface Segregation Principle to “extreme”
Providing that clients would typically consume just one method, though methods would be conceptually related, why not always apply the Interface Segregation Principle to the extreme and have [many] single-method interfaces? Is there an objective rule against this? Not something like “oh it feels wrong” or “but you will have so many types, it’s hard to read and manage” but rather something logical and clear. (Still want to name contracts clearly, so functions are not a good fit?).
Why not apply Interface Segregation Principle to “extreme”
Providing that clients would typically consume just one method, though methods would be conceptually related, why not always apply the Interface Segregation Principle to the extreme and have [many] single-method interfaces? Is there an objective rule against this? Not something like “oh it feels wrong” or “but you will have so many types, it’s hard to read and manage” but rather something logical and clear. (Still want to name contracts clearly, so functions are not a good fit?).
Why not apply Interface Segregation Principle to “extreme”
Providing that clients would typically consume just one method, though methods would be conceptually related, why not always apply the Interface Segregation Principle to the extreme and have [many] single-method interfaces? Is there an objective rule against this? Not something like “oh it feels wrong” or “but you will have so many types, it’s hard to read and manage” but rather something logical and clear. (Still want to name contracts clearly, so functions are not a good fit?).
Why not apply Interface Segregation Principle to “extreme”
Providing that clients would typically consume just one method, though methods would be conceptually related, why not always apply the Interface Segregation Principle to the extreme and have [many] single-method interfaces? Is there an objective rule against this? Not something like “oh it feels wrong” or “but you will have so many types, it’s hard to read and manage” but rather something logical and clear. (Still want to name contracts clearly, so functions are not a good fit?).