2nd/10_Wiki/Topic_Programming/Backend/Ad-hoc-Optimization.md

---
id: wiki-2026-0508-ad-hoc-optimization
title: Ad-hoc Optimization
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Local Optimization, Point Optimization]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [performance, optimization, anti-pattern]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: any
  framework: any
---

# Ad-hoc Optimization

## 매 한 줄
> **"매 measure-then-fix-locally tactic"**. 매 system-wide 매 architectural improvement 의 opposite — 매 single profiler hot-spot 의 surgical fix. 매 effective when bounded, dangerous when systemic problem masked.

## 매 핵심

### 매 mechanism
- 매 profiler → bottleneck → patch → re-profile loop.
- 매 80/20 rule — 매 20% code 의 80% time 의 surgical strike.

### 매 vs systematic
- **Ad-hoc**: caching one query, inlining one loop.
- **Systematic**: index strategy, algorithm change, architecture refactor.

### 매 응용
1. Performance bug regressions (single function got slow).
2. Hot path tuning post-profiling.
3. Pre-launch polish.

## 💻 패턴

### Profile-first (Node.js)
```ts
import { performance } from 'perf_hooks';

const t0 = performance.now();
const result = expensiveFunction(input);
console.log(`took ${performance.now() - t0}ms`);
```

### Memoize one hot function
```ts
const memo = new Map<string, Result>();
function compute(key: string, input: Input): Result {
  if (memo.has(key)) return memo.get(key)!;
  const r = expensiveFunction(input);
  memo.set(key, r);
  return r;
}
```

### Batch one N+1 query
```ts
// Before: O(N) DB roundtrips
for (const u of users) u.posts = await db.posts.where({ userId: u.id });

// After: 1 roundtrip
const posts = await db.posts.whereIn('userId', users.map(u => u.id));
const byUser = groupBy(posts, 'userId');
users.forEach(u => u.posts = byUser[u.id] ?? []);
```

### Hot loop unroll (tight CPU path)
```ts
// Before
for (let i = 0; i < n; i++) sum += arr[i];

// After (4x unrolled)
let i = 0;
for (; i + 3 < n; i += 4) {
  sum += arr[i] + arr[i+1] + arr[i+2] + arr[i+3];
}
for (; i < n; i++) sum += arr[i];
```

### Cache HTTP response (1-line fix)
```ts
app.get('/api/feed', cacheMiddleware({ ttl: 60 }), async (req, res) => {
  res.json(await buildFeed(req.user));
});
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| 1 hot function, rest 매 fine | Ad-hoc fix |
| 매 systemic — many slow paths | Architectural refactor |
| Pre-launch perf polish | Ad-hoc 매 first, systematic later |

**기본값**: Profile → ad-hoc fix → re-profile. 매 escalate to systematic only if 매 ad-hoc 매 insufficient.

## 🔗 Graph
- 부모: [[Performance-Optimization]]
- 변형: [[Memoization]]
- Adjacent: [[Profiling]] · [[Premature-Optimization]]

## 🤖 LLM 활용
**언제**: measured bottleneck, bounded scope.
**언제 X**: 매 system-wide perf issue (architectural fix needed); 매 unmeasured guess (premature optimization).

## ❌ 안티패턴
- **Optimizing without profiling**: 매 wrong target.
- **Local fix masking systemic issue**: e.g., caching to hide N+1 query.
- **Ad-hoc until 매 spaghetti**: 매 too many patches → architectural debt.

## 🧪 검증 / 중복
- Verified (Knuth — premature optimization is the root of all evil; Brendan Gregg — Systems Performance).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Ad-hoc Optimization FULL with profile-first patterns |