2nd/10_Wiki/Topics/Domain_Programming/Architecture/Sprout Method (스프라우트 메서드).md

---
id: wiki-2026-0508-sprout-method-스프라우트-메서드
title: Sprout Method (스프라우트 메서드)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Sprout Method, 스프라우트 메서드]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [refactoring, legacy-code, michael-feathers]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: java
  framework: junit
---

# Sprout Method (스프라우트 메서드)

## 매 한 줄
> **"매 untestable 한 method 의 옆에 매 새 method 의 sprout — 매 새 logic 의 isolation, 매 test 의 가능"**. Michael Feathers 의 *Working Effectively with Legacy Code* (2004) 의 핵심 technique. 매 legacy code 의 modification 시 매 직접 수정 X — 매 옆에 새 method 의 grow.

## 매 핵심

### 매 motivation
- **Legacy method**: 매 too long, too coupled, 매 test 의 X.
- **새 feature 의 add 필요**: 매 직접 수정 → 매 risk 의 폭발.
- **Sprout**: 매 new logic 의 separate method, 매 test 의 first, 매 caller 의 단순 call.

### 매 절차
1. **Identify** 매 change point.
2. **Write** 매 새 method (with tests) — empty 매 body, 매 signature first.
3. **Test-drive** 매 새 method 의 구현.
4. **Call** 매 새 method 의 from legacy code (one line).
5. 매 legacy code 의 거의 untouched.

### 매 응용
1. Bug fix 의 add — 매 새 validation 의 sprout.
2. Feature flag 의 add — 매 새 conditional 의 sprout.
3. Logging 의 add — 매 새 logger call 의 sprout.

## 💻 패턴

### Before sprout
```java
public class OrderProcessor {
    public void process(Order order) {
        // 100+ lines of untested legacy logic
        repository.save(order);
        emailService.send(order.getCustomer(), "thanks");
    }
}
```

### Sprout method 의 적용
```java
public class OrderProcessor {
    public void process(Order order) {
        // 100+ lines untouched
        repository.save(order);
        sendOrderConfirmation(order); // sprouted
    }

    // New method — fully tested
    void sendOrderConfirmation(Order order) {
        var template = order.isPriority()
            ? "priority-thanks"
            : "thanks";
        emailService.send(order.getCustomer(), template);
    }
}
```

### Test 의 새 method (JUnit 5)
```java
@Test
void priorityOrder_usesPriorityTemplate() {
    var order = new Order(customer, true);
    var sut = new OrderProcessor(repo, emailMock);
    sut.sendOrderConfirmation(order);
    verify(emailMock).send(customer, "priority-thanks");
}
```

### Sprout function (procedural)
```python
def process_order(order):
    # Legacy logic untouched
    db.save(order)
    notify_customer(order)  # sprouted free function

def notify_customer(order):
    # New, tested logic
    template = "priority" if order.priority else "standard"
    email.send(order.customer, template)
```

### Sprout 의 static helper
```java
class LegacyService {
    void run() {
        var data = fetch();
        var clean = LegacyService.normalize(data); // sprouted static
        write(clean);
    }
    static String normalize(String s) { return s.strip().toLowerCase(); }
}
```

### Visibility 의 package-private (testability)
```java
// package-private for test access
void sendOrderConfirmation(Order order) { ... }
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Legacy method 의 too risky to refactor | Sprout method |
| 매 새 logic 의 self-contained | Sprout method |
| 매 변경 의 cross-cutting | Sprout class 의 사용 |
| 매 method 의 caller 의 wrapping 필요 | Wrap method (sibling technique) |
| 매 ample test coverage 의 존재 | 매 직접 refactor |

**기본값**: 매 legacy code change → sprout method first. 매 직접 수정 X.

## 🔗 Graph
- 부모: [[Refactoring_Best_Practices|Refactoring]]
- 변형: [[Sprout & Wrap Techniques (스프라우트 & 랩 기법)]]
- 응용: [[Test-Driven Development]]

## 🤖 LLM 활용
**언제**: 매 legacy codebase 의 small additive change, 매 surrounding code 의 untested.
**언제 X**: 매 greenfield code (그냥 inline), 매 logic 의 deeply intertwined (Wrap 의 사용).

## ❌ 안티패턴
- **Sprout 의 then leave**: 매 sprouted method 의 grow 의 indefinite — 매 결국 same problem.
- **No tests for sprout**: 매 point 의 lost — 매 sprout 의 핵심 value 의 testability.
- **Sprout into same class**: 매 class 의 already God class → sprout class 의 사용.

## 🧪 검증 / 중복
- Verified (Feathers, *WELC* ch.6, 2004; Fowler refactoring catalog).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — full sprout method spec with Java/Python patterns |