Substitution and Interface Size: LSP and ISP

The middle two letters of SOLID are the ones most often reduced to textbook shapes — rectangles, squares and birds that cannot fly. Those examples are memorable and they teach the wrong lesson, because they suggest the problem is about taxonomy. It is not. Both principles are about promises: what a caller is entitled to assume, and what an implementer is forced to provide.

In everyday code the violations rarely look like biology. They look like an implementation that throws where the interface implied a value, one that quietly ignores a parameter, one that is dramatically slower than every sibling, or one that requires callers to check its concrete type first. The symptom is always the same: `instanceof` checks or capability flags appearing in code that was supposed to be polymorphic — that is, code written against the interface and expected to work with any implementation of it.

export interface PayoutProvider {
  /** Sends money, optionally on a future date. */
  send(request: PayoutRequest): Promise<PayoutReceipt>;
}

class BankTransferProvider implements PayoutProvider {
  async send(request: PayoutRequest): Promise<PayoutReceipt> {
    return this.api.transfer(request); // honours request.scheduledFor
  }
}

class WalletProvider implements PayoutProvider {
  async send(request: PayoutRequest): Promise<PayoutReceipt> {
    // Violation: strengthens the precondition. Callers holding a
    // PayoutProvider have no way to know this restriction exists.
    if (request.scheduledFor) {
      throw new Error('Wallet payouts are immediate only');
    }
    return this.api.credit(request);
  }
}

// The symptom leaks into the caller, and polymorphism becomes decorative.
if (provider instanceof WalletProvider) {
  request = { ...request, scheduledFor: undefined };
}

• Fix one: narrow the shared interface to what every provider can honestly do, and expose scheduling as a separate optional capability callers can ask for.
• Fix two: let the wallet provider satisfy the promise by scheduling internally — storing the request and releasing it at the due time — so the caller's assumption stays true.
• Fix three: accept that these are different concepts and stop making them share a type, which is often the right answer when only one of two implementations fits.
• What is not a fix: documenting the exception in a comment. A promise that holds only if you read the docs is not a promise a caller can rely on.

The two principles are linked more tightly than their separate letters suggest. Fat interfaces cause substitution violations: when an interface has eleven methods and a new implementation can honour six, the other five become throwing stubs and the interface now lies. Segregating the interface removes the pressure to lie.