Skill: Performance Optimization

Purpose

Apply optimization techniques to improve code performance based on profiling and benchmarking insights. Provides actionable optimization strategies and implementation guidance.

When to Use

• After profiling identifies bottlenecks
• When benchmarks show regression
• Performance requirements not met
• Scaling preparation
• Resource cost optimization
• User experience improvement

---

Optimization Hierarchy

Priority Order

Priority	Category	Typical Impact	Effort
1	Algorithm	10x - 1000x	Medium
2	Data Structure	2x - 100x	Medium
3	I/O Optimization	2x - 50x	Low-Medium
4	Caching	2x - 100x	Low
5	Concurrency	2x - Nx	High
6	Micro-optimization	1.1x - 2x	Low

---

Algorithm Optimization

Complexity Improvements

## Algorithm Optimization Patterns

### O(n²) → O(n log n): Sorting-based Solution
**Before:**
```typescript
// Find duplicates - O(n²)
function findDuplicates(arr: number[]): number[] {
  const dupes = [];
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[i] === arr[j]) dupes.push(arr[i]);
    }
  }
  return dupes;
}

After:

// Find duplicates - O(n)
function findDuplicates(arr: number[]): number[] {
  const seen = new Set<number>();
  const dupes = new Set<number>();
  for (const num of arr) {
    if (seen.has(num)) dupes.add(num);
    seen.add(num);
  }
  return [...dupes];
}

Impact: 1000 items: 500ms → 1ms

### Search Optimization

```markdown
### Linear → Binary Search
**Requirement:** Sorted data

**Before:** O(n)
```typescript
function find(arr: number[], target: number): number {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) return i;
  }
  return -1;
}

After: O(log n)

function find(arr: number[], target: number): number {
  let left = 0, right = arr.length - 1;
  while (left <= right) {
    const mid = Math.floor((left + right) / 2);
    if (arr[mid] === target) return mid;
    if (arr[mid] < target) left = mid + 1;
    else right = mid - 1;
  }
  return -1;
}

Impact: 1M items: 500ms → 0.02ms

---

## Data Structure Optimization

### Choosing Right Structures

| Operation | Array | Object/Map | Set |
|-----------|-------|------------|-----|
| Lookup by index | O(1) | - | - |
| Lookup by key | O(n) | O(1) | O(1) |
| Insert | O(1)/O(n) | O(1) | O(1) |
| Delete | O(n) | O(1) | O(1) |
| Has/Contains | O(n) | O(1) | O(1) |

### Common Transformations

```markdown
### Array to Map for Lookups

**Before:**
```typescript
// O(n) per lookup
users.find(u => u.id === targetId);

After:

// O(1) per lookup after O(n) build
const userMap = new Map(users.map(u => [u.id, u]));
userMap.get(targetId);

Use when: Multiple lookups on same dataset

---

## I/O Optimization

### Database Query Optimization

```markdown
## Database Optimization Patterns

### N+1 Query Problem
**Before:**
```typescript
// N+1 queries
const orders = await Order.findAll();
for (const order of orders) {
  order.customer = await Customer.findById(order.customerId);
}

After:

// 2 queries with JOIN or batch
const orders = await Order.findAll({
  include: [Customer]
});
// OR
const orders = await Order.findAll();
const customerIds = orders.map(o => o.customerId);
const customers = await Customer.findAll({
  where: { id: { in: customerIds } }
});

Index Optimization

-- Add index for frequently filtered column
CREATE INDEX idx_orders_customer_id ON orders(customer_id);

-- Composite index for multi-column queries
CREATE INDEX idx_orders_status_date ON orders(status, created_at);

Query Optimization

-- Before: Full table scan
SELECT * FROM orders WHERE YEAR(created_at) = 2024;

-- After: Index-friendly
SELECT * FROM orders
WHERE created_at >= '2024-01-01'
  AND created_at < '2025-01-01';

### Network Optimization

```markdown
## Network Optimization

### Batch Requests
**Before:**
```typescript
// 100 network calls
for (const id of ids) {
  await api.getItem(id);
}

After:

// 1 network call
const items = await api.getItems(ids);

Compression

// Enable compression
app.use(compression({
  level: 6,
  threshold: 1024
}));

Connection Pooling

// Reuse connections
const pool = new Pool({
  max: 20,
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000
});

---

## Caching Strategies

### Cache Patterns

```markdown
## Caching Optimization

### In-Memory Cache
```typescript
const cache = new Map<string, { data: any; expires: number }>();

async function getCached<T>(
  key: string,
  fetcher: () => Promise<T>,
  ttlMs: number = 60000
): Promise<T> {
  const cached = cache.get(key);
  if (cached && cached.expires > Date.now()) {
    return cached.data;
  }

  const data = await fetcher();
  cache.set(key, { data, expires: Date.now() + ttlMs });
  return data;
}

Memoization

function memoize<T extends (...args: any[]) => any>(fn: T): T {
  const cache = new Map();
  return ((...args: any[]) => {
    const key = JSON.stringify(args);
    if (cache.has(key)) return cache.get(key);
    const result = fn(...args);
    cache.set(key, result);
    return result;
  }) as T;
}

const expensiveCalc = memoize((n: number) => {
  // Complex calculation
});

Cache Invalidation Strategies

Strategy	Use Case	Complexity
TTL	Time-based expiry	Low
LRU	Size-limited cache	Medium
Event-based	Data changes	High
Versioned	Immutable data	Low

---

## Concurrency Optimization

### Parallel Processing

```markdown
## Concurrency Patterns

### Promise.all for Independent Operations
**Before:**
```typescript
// Sequential - 3 seconds
const a = await fetchA(); // 1s
const b = await fetchB(); // 1s
const c = await fetchC(); // 1s

After:

// Parallel - 1 second
const [a, b, c] = await Promise.all([
  fetchA(),
  fetchB(),
  fetchC()
]);

Controlled Concurrency

async function processWithLimit<T>(
  items: T[],
  fn: (item: T) => Promise<void>,
  limit: number
): Promise<void> {
  const executing: Promise<void>[] = [];

  for (const item of items) {
    const p = fn(item).then(() => {
      executing.splice(executing.indexOf(p), 1);
    });
    executing.push(p);

    if (executing.length >= limit) {
      await Promise.race(executing);
    }
  }

  await Promise.all(executing);
}

// Process 100 items, max 10 concurrent
await processWithLimit(items, processItem, 10);

---

## Memory Optimization

### Reducing Memory Footprint

```markdown
## Memory Optimization

### Streaming Large Data
**Before:**
```typescript
// Loads entire file into memory
const data = fs.readFileSync('large.json');
const parsed = JSON.parse(data);

After:

// Streams and processes chunks
const stream = fs.createReadStream('large.json');
const parser = JSONStream.parse('*');
stream.pipe(parser).on('data', (item) => {
  processItem(item);
});

Object Pooling

class ObjectPool<T> {
  private pool: T[] = [];

  constructor(
    private factory: () => T,
    private reset: (obj: T) => void,
    private maxSize: number = 100
  ) {}

  acquire(): T {
    return this.pool.pop() || this.factory();
  }

  release(obj: T): void {
    if (this.pool.length < this.maxSize) {
      this.reset(obj);
      this.pool.push(obj);
    }
  }
}

Avoiding Memory Leaks

// Clean up event listeners
class Component {
  private handler = () => { /* ... */ };

  mount() {
    eventBus.on('event', this.handler);
  }

  unmount() {
    eventBus.off('event', this.handler);
  }
}

---

## Optimization Report Template

```markdown
## Optimization Report

**Target:** {{component}}
**Before Baseline:** {{baseline_metrics}}
**After Optimization:** {{new_metrics}}

### Optimizations Applied

#### 1. Algorithm Improvement
- **Change:** Replaced O(n²) search with O(n) using Map
- **Impact:** 95% reduction in processing time
- **Risk:** Low

#### 2. Database Query Optimization
- **Change:** Resolved N+1 query with JOIN
- **Impact:** 10x fewer database calls
- **Risk:** Low

#### 3. Added Caching Layer
- **Change:** Implemented Redis cache for API responses
- **Impact:** 80% reduction in database load
- **Risk:** Medium (cache invalidation)

### Results

| Metric | Before | After | Improvement |
|--------|--------|-------|-------------|
| Response Time | 450ms | 45ms | 90% |
| Database Queries | 100 | 2 | 98% |
| Memory Usage | 512MB | 128MB | 75% |
| Throughput | 50 rps | 500 rps | 10x |

### Verification
- [x] All tests passing
- [x] Benchmarks within target
- [x] No regression in other areas
- [x] Monitoring in place

---

Agents Using This Skill

• Senior Developer - Implementation
• Software Architect - Architecture optimization
• DevOps Engineer - Infrastructure optimization

Related Skills

• performance-profiling - Find what to optimize
• performance-benchmarking - Measure improvements
• analysis-code - Code analysis

MCP Tools Used

• github-pr-creation - Optimization PRs
• jira-task-management - Track optimization work