---
id: wiki-2026-0508-rule-of-three
title: Rule of Three
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Three Strikes Rule, DRY Trigger, Triplication Rule]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [refactoring, dry, software-engineering, code-smell, abstraction]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: agnostic
  framework: refactoring
---

# Rule of Three

## 매 한 줄
> **"매 첫 두 번의 중복은 참아라. 세 번째에 추상화하라"**. Martin Fowler 가 *Refactoring* (1999) 에서 codify 한 heuristic — 매 premature abstraction 의 cost 가 duplication 의 cost 보다 큰 까닭에, 매 세 번째 instance 에서 야 진짜 pattern 이 보인다는 pragmatic guideline. 매 2026 년 까지 매 senior eng 의 default mental model.

## 매 핵심

### 매 origin (Don Roberts → Fowler)
- Don Roberts 가 처음 articulate, Fowler 가 *Refactoring* (1999) book 에서 popularize.
- 매 underlying principle: 매 abstraction 은 매 미래 의 use case 의 prediction. 매 N=2 일 때 prediction 의 sample size 부족. 매 N=3 에서 야 매 commonality 가 진짜 인지 vs 매 우연 인지 distinguishable.

### 매 trade-off
- **매 abstraction cost**: 매 wrong abstraction 의 cost ≫ 매 duplication 의 cost (Sandi Metz 의 famous talk: "duplication is far cheaper than the wrong abstraction").
- **매 cognitive load**: 매 abstraction 의 매 indirection 추가 → 매 reader 가 매 hop 따라 가야.
- **매 lock-in**: 매 abstraction 일찍 commit 시 매 future divergence 시 매 rollback cost 큼.

### 매 응용
1. **함수 추출**: 매 동일 logic 의 3 번째 copy 시 → extract function.
2. **클래스 hierarchy**: 매 3 번째 subclass 의 emerging 시 → introduce base class.
3. **Config / parameter**: 매 magic number 의 3 번째 occurrence 시 → constant 화.

## 💻 패턴

### Pattern 1: Duplication tolerated (N=2)
```typescript
// 매 OK — 매 2 번 만의 duplication. 매 abstraction X.
function calcOrderTotal(items: Item[]) {
  return items.reduce((sum, i) => sum + i.price * i.qty, 0);
}

function calcCartPreview(items: Item[]) {
  // 매 looks similar but 매 different context — leave it.
  return items.reduce((sum, i) => sum + i.price * i.qty, 0);
}
```

### Pattern 2: 3rd occurrence → extract
```typescript
// 매 3 번째 copy 등장 시 abstract.
const sumLineItems = (items: Item[]) =>
  items.reduce((sum, i) => sum + i.price * i.qty, 0);

const calcOrderTotal = sumLineItems;
const calcCartPreview = sumLineItems;
const calcInvoiceTotal = sumLineItems;  // 매 trigger
```

### Pattern 3: Generic-too-early anti-example
```typescript
// 매 BAD — 매 N=1 에서 매 over-generalize.
function processCollection<T, R>(
  data: T[],
  reducer: (acc: R, x: T) => R,
  initial: R,
  filter?: (x: T) => boolean,
  mapper?: (x: T) => T
): R {
  // 매 future-proofing 의 환상. 매 actual 사용 = 매 1 case.
}
```

### Pattern 4: Sandi Metz 의 "prefer duplication"
```ruby
# 매 duplicate code 는 매 wrong abstraction 보다 매 fix easier.
# 매 wrong abstraction = 매 매 caller refactor 필요.
class OrderTotal
  def calculate(items)
    items.sum { |i| i.price * i.qty }
  end
end

class CartPreview
  def calculate(items)
    items.sum { |i| i.price * i.qty }  # 매 duplicate intentional until N=3
  end
end
```

### Pattern 5: 매 React component 의 Rule of Three
```tsx
// 매 1st: inline.
<button className="bg-blue-500 px-4 py-2 rounded">Save</button>

// 매 2nd: 그냥 copy.
<button className="bg-blue-500 px-4 py-2 rounded">Cancel</button>

// 매 3rd: abstract.
const PrimaryButton = ({ children, ...rest }) => (
  <button className="bg-blue-500 px-4 py-2 rounded" {...rest}>{children}</button>
);
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 N=1 (one-off) | Inline. 매 abstraction X. |
| 매 N=2 (duplication 등장) | Wait. 매 watch for 3rd. |
| 매 N=3 (triplication) | Extract — 매 pattern crystallized. |
| 매 cross-domain duplication (uncertain pattern) | Wait — 매 4-5 까지 도 OK. |
| 매 critical bug-prone duplication | Extract early — 매 correctness ≫ 매 abstraction cost. |

**기본값**: 매 N=3 까지 wait. 매 doubt 시 duplicate.

## 🔗 Graph
- 부모: [[DRY Principle]] · [[Refactoring_Best_Practices|Refactoring]]
- 변형: [[YAGNI]]
- 응용: [[Extract Function]] · [[Extract Class]]
- Adjacent: [[Code Smell]]

## 🤖 LLM 활용
**언제**: 매 codebase 의 duplication 매 detect → 매 N count 후 매 refactor 제안.
**언제 X**: 매 N=2 에서 매 LLM 의 over-eager abstraction 제안 — reject.

## ❌ 안티패턴
- **DRY 원리주의 (DRY zealotry)**: 매 N=1 에서 매 abstract → 매 wrong shape.
- **Forever duplication**: 매 N=10 도 매 ignore — 매 maintenance disaster.
- **Hasty generalization**: 매 surface similarity 만 보고 매 abstract — 매 underlying domain 의 different.

## 🧪 검증 / 중복
- Verified (Fowler *Refactoring* 1st/2nd ed; Sandi Metz "All the Little Things" RailsConf 2014).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Rule of Three 의 origin/trade-off/patterns/Metz 의 "prefer duplication" 정리 |
