Divergent change & shotgun surgery

Divergent change: one module is edited for many unrelated reasons. When you add a payment provider, this class changes. When the tax rules change, this class changes. When the email template changes, this class changes again. Three different requirement directions, all landing in the same file. That is divergent change — a symptom of low cohesion, because the module bundles responsibilities that vary independently.

// OrderService.ts — touched by three unrelated forces
class OrderService {
  charge(order: Order) { /* Stripe API specifics — changes when payments change */ }
  computeTax(order: Order) { /* VAT rules — changes when tax law changes */ }
  sendReceipt(order: Order) { /* HTML email body — changes when marketing changes */ }
}

The tell is in the history: the same file appears in commits whose messages have nothing to do with each other — “switch to Adyen”, “add EU VAT”, “new receipt design”. The fix is to split along the axes of change so each new requirement has one obvious home.

Shotgun surgery: one logical change forces edits across many modules. It is the exact inverse. You decide to add a new currency, and you find yourself editing the cart, the checkout summary, the invoice generator, the receipt email, and the admin export — five files for one conceptual change. That is shotgun surgery — a symptom of high coupling, because one responsibility has been smeared across modules that all hold a fragment of it.

// the SAME rule (how to render money) re-implemented in five places
cart.ts:      const label = currency === 'USD' ? '$' + amt : '€' + amt;
checkout.ts:  const label = currency === 'USD' ? '$' + amt : '€' + amt;
invoice.ts:   const label = currency === 'USD' ? '$' + amt : '€' + amt;
// ...and two more

The tell is again in the history: a single commit (or, worse, several commits chasing the same bug) touches a scatter of files that should have nothing in common. The fix is to consolidate the scattered fragments behind one boundary, so the next currency is one edit.

These are the empirical SRP smells — you read them off co-change, you don’t argue them. The Single Responsibility Principle is usually stated as “a class should have one reason to change.” That definition is operational, not philosophical: a reason to change is observable. Build a co-change map — for each pair of files (or each file’s set of commit reasons), how often do they change together and why?

// crude co-change signal from history (conceptual)
// git log --name-only --pretty=format:%s  →  group files by commit
// divergent change:  one file, many unrelated commit subjects
// shotgun surgery:   one commit subject, many unrelated files

• Divergent change = one file, high diversity of change reasons. Cohesion is low; the file is doing several jobs. Split it.
• Shotgun surgery = one change reason, high diversity of files touched. Coupling is high; one job is spread out. Gather it.

This is why the smells beat the abstract debate: two seniors can disagree forever about whether OrderService “has one responsibility”, but they cannot disagree that its history shows three independent change axes. The repository is the referee.

The refactoring direction is opposite for each — and choosing wrong makes it worse. Divergent change wants separation: Extract Class / Move Method until each module varies for one reason. Shotgun surgery wants gathering: Move Method / Inline / Combine until each reason lives in one module. They pull in opposite directions, so the diagnosis must come first.

// divergent change → SPLIT (raise cohesion)
class PaymentGateway { charge(order: Order) {/* … */} }
class TaxCalculator  { computeTax(order: Order) {/* … */} }
class ReceiptMailer  { send(order: Order) {/* … */} }

// shotgun surgery → CONSOLIDATE (lower coupling)
// money.ts — the one place the "render money" rule lives
export function formatMoney(amt: number, currency: Currency): string { /* … */ }
// cart/checkout/invoice now all call formatMoney(amt, currency)

If you “fix” divergent change by gathering, you build a bigger god class. If you “fix” shotgun surgery by splitting, you scatter the responsibility even more. The smell names the cure; that is the whole point of naming them separately.