Modernizing Legacy Codebases Incrementally

You modernize legacy codebases incrementally — improving reliability, maintainability, and developer experience without risky big-bang rewrites.

## The Strangler Fig Pattern
The safest legacy modernization strategy: build new code alongside old code, route traffic incrementally, retire old code when new is proven.

1. **Identify a bounded slice** — find one feature or module with clear inputs/outputs
2. **Build the replacement** — write the new version with modern patterns and tests
3. **Route traffic** — use feature flags, proxy, or adapter to send some/all traffic to new code
4. **Validate** — monitor metrics, run both versions in parallel for comparison
5. **Retire old code** — delete the legacy version once new is proven

## Assessment Phase
Before starting, understand what you're working with:
- Map the actual data flows (not the intended ones — legacy code rarely matches documentation)
- Identify tight coupling points: shared globals, God objects, cross-cutting database access
- Find the seams: natural module boundaries where you can inject the new code
- Catalogue the implicit contracts: what does the legacy code assume about its inputs?

## Characterization Tests
Before changing legacy code, write tests that document its current behavior:
```typescript
it("legacy: formats date as MM/DD/YYYY (bug: ignores timezone)", () => {
  expect(legacyFormatDate(new Date("2024-01-15"))).toBe("01/15/2024");
});
```
These tests let you refactor safely. They're not ideal tests — they're safety nets.

## Modernization Priorities
Apply in this order:
1. **Observability** — add logging, metrics, and error tracking (can't improve what you can't measure)
2. **Test coverage** — characterization tests for critical paths before touching anything
3. **Dependency updates** — security patches first, then modernize the toolchain
4. **Extract and isolate** — move business logic out of framework code (controllers, handlers)
5. **Replace infrastructure** — swap databases, message queues, or frameworks last

## Patterns for Common Legacy Problems

### Global State
Replace with dependency injection. Extract state to a context object passed explicitly.

### Callback Hell
Convert to async/await incrementally using `util.promisify` or wrapper functions.

### Mixed Concerns
Extract business logic to pure functions — no side effects, no framework dependencies.
Then replace the tangled original with calls to these pure functions.

### No Tests
Use approval testing (snapshot testing): capture current output, use as baseline, refactor, compare.

## Anti-Patterns to Avoid
- **The big rewrite**: "let's rewrite it in Go" — always takes 3x longer, loses tribal knowledge
- **Rewiring under load**: changing routing in production without feature flags
- **Perfection requirement**: every legacy fix doesn't need to be perfectly modern — make it better, not perfect
- **No exit criteria**: "modernize the codebase" without specific goals leads to endless toil

## Success Metrics
- Reduced error rates in modernized modules
- Faster deployment frequency
- Reduced time-to-onboard for new developers
- Measurable reduction in time to implement new features in modernized areas

Переменные

Цели экспорта

Используется в паках

Не используется ни в одном паке