82 lines
2.9 KiB
Markdown
82 lines
2.9 KiB
Markdown
---
|
|
name: Simplification Cascades
|
|
description: Find one insight that eliminates multiple components - "if this is true, we don't need X, Y, or Z"
|
|
when_to_use: when implementing the same concept multiple ways, accumulating special cases, or complexity is spiraling
|
|
version: 1.1.0
|
|
credit: https://github.com/obra
|
|
---
|
|
|
|
# Simplification Cascades
|
|
|
|
## Overview
|
|
|
|
Sometimes one insight eliminates 10 things. Look for the unifying principle that makes multiple components unnecessary.
|
|
|
|
**Core principle:** "Everything is a special case of..." collapses complexity dramatically.
|
|
|
|
## Quick Reference
|
|
|
|
| Symptom | Likely Cascade |
|
|
| ------------------------------ | ------------------------------------ |
|
|
| Same thing implemented 5+ ways | Abstract the common pattern |
|
|
| Growing special case list | Find the general case |
|
|
| Complex rules with exceptions | Find the rule that has no exceptions |
|
|
| Excessive config options | Find defaults that work for 95% |
|
|
|
|
## The Pattern
|
|
|
|
**Look for:**
|
|
|
|
- Multiple implementations of similar concepts
|
|
- Special case handling everywhere
|
|
- "We need to handle A, B, C, D differently..."
|
|
- Complex rules with many exceptions
|
|
|
|
**Ask:** "What if they're all the same thing underneath?"
|
|
|
|
## Examples
|
|
|
|
### Cascade 1: Stream Abstraction
|
|
|
|
**Before:** Separate handlers for batch/real-time/file/network data
|
|
**Insight:** "All inputs are streams - just different sources"
|
|
**After:** One stream processor, multiple stream sources
|
|
**Eliminated:** 4 separate implementations
|
|
|
|
### Cascade 2: Resource Governance
|
|
|
|
**Before:** Session tracking, rate limiting, file validation, connection pooling (all separate)
|
|
**Insight:** "All are per-entity resource limits"
|
|
**After:** One ResourceGovernor with 4 resource types
|
|
**Eliminated:** 4 custom enforcement systems
|
|
|
|
### Cascade 3: Immutability
|
|
|
|
**Before:** Defensive copying, locking, cache invalidation, temporal coupling
|
|
**Insight:** "Treat everything as immutable data + transformations"
|
|
**After:** Functional programming patterns
|
|
**Eliminated:** Entire classes of synchronization problems
|
|
|
|
## Process
|
|
|
|
1. **List the variations** - What's implemented multiple ways?
|
|
2. **Find the essence** - What's the same underneath?
|
|
3. **Extract abstraction** - What's the domain-independent pattern?
|
|
4. **Test it** - Do all cases fit cleanly?
|
|
5. **Measure cascade** - How many things become unnecessary?
|
|
|
|
## Red Flags You're Missing a Cascade
|
|
|
|
- "We just need to add one more case..." (repeating forever)
|
|
- "These are all similar but different" (maybe they're the same?)
|
|
- Refactoring feels like whack-a-mole (fix one, break another)
|
|
- Growing configuration file
|
|
- "Don't touch that, it's complicated" (complexity hiding pattern)
|
|
|
|
## Remember
|
|
|
|
- Simplification cascades = 10x wins, not 10% improvements
|
|
- One powerful abstraction > ten clever hacks
|
|
- The pattern is usually already there, just needs recognition
|
|
- Measure in "how many things can we delete?"
|