performance-optimizer

Performance Optimizer Skill

This skill helps identify and resolve performance issues across the application stack. Use this whenever you need to profile code, optimize algorithms, implement caching, or improve system throughput.

Performance Principles

1. Optimization Rules

1. Don't optimize prematurely - Measure first, optimize second
2. Profile before guessing - Data beats intuition
3. Optimize the critical path - Focus on what matters most
4. Consider trade-offs - Speed vs memory vs complexity

2. Performance Metrics

Metric	Description	Target
Latency	Time to complete one operation	< 100ms (API)
Throughput	Operations per unit time	Depends on load
p50/p95/p99	Percentile latencies	p99 < 2x p50
TTFB	Time to first byte	< 200ms
Memory usage	RAM consumption	Within limits
CPU usage	Processor utilization	< 70% sustained

3. Big O Quick Reference

Complexity	Name	Example
O(1)	Constant	Hash lookup, array access
O(log n)	Logarithmic	Binary search
O(n)	Linear	Array iteration
O(n log n)	Linearithmic	Efficient sorting
O(n²)	Quadratic	Nested loops
O(2ⁿ)	Exponential	Recursive fibonacci

Profiling Techniques

Python Profiling

# cProfile - Function-level profiling
import cProfile
import pstats

def profile_code():
    profiler = cProfile.Profile()
    profiler.enable()
    
    # Code to profile
    result = expensive_function()
    
    profiler.disable()
    stats = pstats.Stats(profiler)
    stats.sort_stats('cumulative')
    stats.print_stats(20)  # Top 20 functions

# Line profiler (install: pip install line-profiler)
# Add @profile decorator to functions
# Run: kernprof -l -v script.py

from line_profiler import profile

@profile
def slow_function():
    result = []
    for i in range(10000):
        result.append(i ** 2)  # Line-by-line timing
    return result

# Memory profiler (install: pip install memory-profiler)
from memory_profiler import profile

@profile
def memory_hungry():
    large_list = [i for i in range(1000000)]
    return sum(large_list)

# Timing decorator
import time
from functools import wraps

def timing(f):
    @wraps(f)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = f(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{f.__name__} took {elapsed:.4f} seconds")
        return result
    return wrapper

@timing
def my_function():
    # Function code
    pass