Performance Profiler

Identifies and suggests fixes for common performance bottlenecks in code.

When to Use

• •User reports performance issues or slow code
• •Optimization requests
• •Code review for performance
• •User mentions "slow", "bottleneck", "optimization", "memory leak"

Instructions

1. Identify Performance Anti-Patterns

N+1 Query Problems:

// Bad: N+1 queries
users.forEach(user => {
  const posts = db.query('SELECT * FROM posts WHERE user_id = ?', user.id);
});

// Good: Single query with JOIN
const usersWithPosts = db.query('SELECT * FROM users LEFT JOIN posts ON users.id = posts.user_id');

Inefficient Loops:

# Bad: O(n²) nested loops
for item in list1:
    for other in list2:
        if item.id == other.id:
            process(item, other)

# Good: O(n) with hash map
lookup = {other.id: other for other in list2}
for item in list1:
    if item.id in lookup:
        process(item, lookup[item.id])

Unnecessary Re-renders (React):

// Bad: Creates new object on every render
<Component style={{ margin: 10 }} />

// Good: Define outside or useMemo
const style = { margin: 10 };
<Component style={style} />

Memory Leaks:

• •Event listeners not cleaned up
• •Timers not cleared
• •Circular references
• •Large caches without limits

Blocking Operations:

• •Synchronous file I/O
• •Long-running calculations in UI thread
• •Missing pagination

2. Database Performance

Check for:

• •Missing indexes on foreign keys
• •SELECT * instead of specific columns
• •Queries in loops (N+1)
• •Missing query limits
• •Inefficient JOINs

Suggest:

• •Add indexes: CREATE INDEX idx_user_id ON posts(user_id);
• •Use eager loading/prefetching
• •Implement pagination
• •Use database query analyzers (EXPLAIN)

3. Algorithm Complexity

Identify:

• •O(n²) or worse algorithms
• •Redundant calculations
• •Unnecessary sorting
• •Inefficient data structures

Common fixes:

• •Hash maps for O(1) lookup vs O(n) array search
• •Binary search O(log n) vs linear search O(n)
• •Memoization for repeated calculations
• •Lazy evaluation for expensive operations

4. Frontend Performance

Check for:

• •Large bundle sizes
• •Unoptimized images
• •Missing code splitting
• •Inefficient React components
• •Missing memoization

Suggest:

• •Lazy loading: const Component = lazy(() => import('./Component'));
• •Image optimization
• •Debounce/throttle expensive operations
• •Virtual scrolling for long lists
• •Web Workers for heavy computations

5. Network Performance

Issues:

• •Too many HTTP requests
• •Large payloads
• •Missing caching
• •Synchronous requests

Solutions:

• •Bundle/concatenate resources
• •Implement compression (gzip, brotli)
• •Use HTTP/2 multiplexing
• •Add caching headers
• •Parallel vs sequential requests

6. Generate Performance Report

Performance Analysis
===================

Critical Issues (Fix Immediately):
1. N+1 query in UserController.index (file.js:45)
   - Impact: 100+ DB queries per request
   - Fix: Use eager loading or JOIN

2. Memory leak in EventEmitter (file.js:120)
   - Impact: Memory grows unbounded
   - Fix: Remove listeners in cleanup

High Priority:
3. O(n²) loop in processData (file.js:200)
   - Impact: Slow for large datasets
   - Fix: Use hash map for O(n)

Medium Priority:
4. Missing image optimization
   - Impact: Slow page load
   - Fix: Use next/image or optimize manually

7. Profiling Tools

JavaScript:

• •Chrome DevTools Performance tab
• •Node.js --inspect flag
• •console.time() / console.timeEnd()

Python:

• •cProfile module
• •line_profiler
• •memory_profiler

Database:

• •EXPLAIN / EXPLAIN ANALYZE
• •Slow query log
• •pg_stat_statements (PostgreSQL)

Best Practices

• •Profile before optimizing
• •Focus on hot paths (80/20 rule)
• •Measure impact of changes
• •Consider readability vs performance trade-offs
• •Document performance-critical sections