## Refactoring Framework ### Phase 1: Code Assessment ``` Assess code for refactoring: **Code/Module:** [Path or paste code] **Context:** [What this code does] **Pain Points:** [Current issues] Assessment checklist: 1. **Code Smells Detection** - [ ] Long methods (>20 lines) - [ ] Large classes (>200 lines) - [ ] Long parameter lists (>3 params) - [ ] Duplicate code - [ ] Feature envy (method uses other class's data) - [ ] Data clumps (params that travel together) - [ ] Primitive obsession (strings/numbers for concepts) - [ ] Switch statements on type - [ ] Parallel inheritance hierarchies - [ ] Speculative generality (unused abstractions) - [ ] Dead code 2. **Complexity Metrics** - Cyclomatic complexity per function - Nesting depth - Coupling between modules - Test coverage 3. **Maintainability Issues** - Hard-coded values - Mixed abstraction levels - Unclear naming - Missing or outdated comments - Implicit dependencies 4. **Risk Assessment** - Is this code well-tested? - How often does it change? - How critical is it? - Who understands it? Generate refactoring priority matrix. ``` ### Phase 2: Refactoring Catalog ```` Apply refactoring patterns: **Code Smell:** [Identified issue] **Context:** [Code snippet or description] Common refactoring patterns: 1. **Extract Method** ```javascript // Before: Long method with multiple responsibilities function processOrder(order) { // validate order (10 lines) // calculate total (15 lines) // apply discounts (20 lines) // save to database (5 lines) } // After: Small, focused methods function processOrder(order) { validateOrder(order); const total = calculateTotal(order); const finalPrice = applyDiscounts(total, order.customer); saveOrder(order, finalPrice); } ```` 2. **Extract Class** ```javascript // Before: Class doing too much class User { // user data + address data + billing data + preferences } // After: Focused classes class User { address: Address; billing: BillingInfo; preferences: UserPreferences; } ``` 3. **Replace Conditional with Polymorphism** ```javascript // Before: Switch on type function calculatePay(employee) { switch(employee.type) { case 'hourly': return employee.hours * employee.rate; case 'salary': return employee.salary / 12; case 'commission': return employee.sales * 0.1; } } // After: Polymorphic classes abstract class Employee { abstract calculatePay(): number; } class HourlyEmployee extends Employee { ... } class SalariedEmployee extends Employee { ... } ``` 4. **Introduce Parameter Object** ```typescript // Before: Long parameter list function createUser(name, email, address, city, zip, phone) {} // After: Parameter object interface CreateUserParams { name: string; email: string; address: Address; phone?: string; } function createUser(params: CreateUserParams) {} ``` 5. **Replace Magic Numbers with Constants** ```javascript // Before if (user.age >= 21) { ... } if (order.total > 100) { ... } // After const LEGAL_DRINKING_AGE = 21; const FREE_SHIPPING_THRESHOLD = 100; if (user.age >= LEGAL_DRINKING_AGE) { ... } if (order.total > FREE_SHIPPING_THRESHOLD) { ... } ``` 6. **Compose Method** ```javascript // Before: Method at multiple abstraction levels function sendReport() { const data = db.query('SELECT * FROM sales...'); let html = '<table>'; for (const row of data) { html += `<tr><td>${row.name}</td>...`; } email.send(config.reportRecipient, html); } // After: Consistent abstraction level function sendReport() { const salesData = fetchSalesData(); const reportHtml = formatAsHtmlTable(salesData); sendReportEmail(reportHtml); } ``` Select appropriate refactoring for the identified smell. ``` ### Phase 3: Safe Refactoring Process ``` Execute refactoring safely: **Target:** [Code to refactor] **Refactoring:** [Pattern to apply] **Risk Level:** [Low/Medium/High] Safe refactoring steps: 1. **Preparation** - [ ] Ensure tests pass (or add them first) - [ ] Commit current state - [ ] Create feature branch - [ ] Identify all callers/dependencies 2. **Incremental Changes** ``` For each small refactoring step: 1. Make ONE change 2. Run tests 3. Verify behavior unchanged 4. Commit with descriptive message 5. Repeat ``` 3. **Parallel Implementation** (for risky changes) ```javascript // Step 1: Add new implementation alongside old function oldMethod() { /* original code */ } function newMethod() { /* refactored code */ } // Step 2: Feature flag to switch function method() { if (useNewImplementation) { return newMethod(); } return oldMethod(); } // Step 3: Validate in production // Step 4: Remove old code ``` 4. **Verification Checklist** - [ ] All existing tests pass - [ ] New edge cases covered - [ ] Performance not degraded - [ ] Behavior verified manually - [ ] Code review completed 5. **Rollback Plan** - Keep old code accessible briefly - Feature flag for instant rollback - Monitor errors after deployment Execute refactoring with step-by-step commits. ``` ### Phase 4: Technical Debt Reduction ``` Develop technical debt strategy: **Codebase:** [Size, age, team] **Current State:** [Pain points, metrics] **Goal:** [Target state] Debt reduction approach: 1. **Debt Inventory** | Area | Type | Impact | Effort | Priority | |------|------|--------|--------|----------| | Auth module | Complexity | High | Medium | 1 | | API layer | Duplication | Medium | Low | 2 | | Tests | Coverage | High | High | 3 | 2. **Prioritization Framework** ``` Priority = (Impact × Frequency of Change) / Effort Focus on: - High impact, low effort (quick wins) - High impact in hot paths (code that changes often) - Blockers for planned features ``` 3. **Refactoring Budget** - Allocate 20% of sprint capacity - Or: 1 refactoring task per sprint - Or: Refactoring Fridays - Track debt reduction over time 4. **Boy Scout Rule** "Leave the code better than you found it" - Small improvements with every PR - Add tests when fixing bugs - Improve naming when reading code - Extract methods when adding features 5. **Metrics to Track** - Code coverage trend - Cyclomatic complexity - Duplicate code percentage - Build/test time - Bug escape rate Create technical debt reduction roadmap. ``` ## Design Pattern Applications ``` Apply design patterns when refactoring: **Strategy Pattern** - Replace conditionals with interchangeable algorithms **Factory Pattern** - Centralize object creation **Decorator Pattern** - Add behavior without inheritance **Observer Pattern** - Decouple event producers/consumers **Repository Pattern** - Abstract data access Example: Strategy Pattern // Before: Conditionals for different behaviors class ShippingCalculator { calculate(order) { if (order.method === 'ground') { return order.weight _ 1.5; } else if (order.method === 'express') { return order.weight _ 3.0 + 10; } else if (order.method === 'overnight') { return order.weight \* 5.0 + 25; } } } // After: Strategy pattern interface ShippingStrategy { calculate(order: Order): number; } class GroundShipping implements ShippingStrategy { ... } class ExpressShipping implements ShippingStrategy { ... } class OvernightShipping implements ShippingStrategy { ... } class ShippingCalculator { constructor(private strategy: ShippingStrategy) {} calculate(order: Order): number { return this.strategy.calculate(order); } } ```` ## Best Practices 1. **Test First**: Never refactor without tests 2. **Small Steps**: One change at a time 3. **Commit Often**: Each step is a safe commit 4. **Don't Mix**: Refactoring != adding features 5. **Measure Impact**: Track improvement metrics 6. **Document Why**: Explain non-obvious changes 7. **Get Reviews**: Fresh eyes catch issues 8. **Know When to Stop**: Good enough is good enough ## Example Session **User**: "This function is 200 lines long and handles user registration. Help me refactor it." **Response**: > I'll help you break down this registration function. Here's my analysis: > > **Identified Responsibilities:** > 1. Input validation (lines 10-45) > 2. Password hashing (lines 46-52) > 3. User creation (lines 53-80) > 4. Email verification setup (lines 81-120) > 5. Welcome email sending (lines 121-150) > 6. Analytics tracking (lines 151-180) > 7. Error handling throughout > > **Refactoring Plan:** > > ```typescript > // Step 1: Extract validation > async function registerUser(input: RegisterInput): Promise<User> { > const validated = await validateRegistration(input); > const passwordHash = await hashPassword(validated.password); > const user = await createUser({ ...validated, passwordHash }); > await setupEmailVerification(user); > await sendWelcomeEmail(user); > trackRegistration(user); > return user; > } > ``` > > **Execution order:** > 1. Add tests for current behavior > 2. Extract `validateRegistration()` - commit > 3. Extract `hashPassword()` - commit > 4. Extract `createUser()` - commit > 5. Continue for each responsibility > > Shall I start with the validation extraction? ## Related Resources - [Refactoring by Martin Fowler](https://refactoring.com/) - [Clean Code by Robert Martin](https://www.oreilly.com/library/view/clean-code-a/9780136083238/) - [Working Effectively with Legacy Code](https://www.oreilly.com/library/view/working-effectively-with/0131177052/) - [Refactoring Guru](https://refactoring.guru/) ````