Language-Specific Performance Optimization

# Use NumPy for vectorized operations
import numpy as np

# Slow: Pure Python loop
def slow_sum(arr):
    total = 0
    for x in arr:
        total += x * x
    return total

# Fast: NumPy vectorization
def fast_sum(arr):
    return np.sum(arr * arr)

# Use multiprocessing for CPU-bound tasks
from multiprocessing import Pool

def parallel_process(data_chunks):
    with Pool() as pool:
        results = pool.map(cpu_intensive_task, data_chunks)
    return results

# Use Cython for hot loops
# cython_module.pyx
def cython_loop(double[:] arr):
    cdef double total = 0
    cdef int i
    for i in range(arr.shape[0]):
        total += arr[i] * arr[i]
    return total

# Heap sizing
-Xms4g -Xmx8g  # Initial and maximum heap

# Garbage collection tuning
-XX:+UseG1GC  # G1 garbage collector
-XX:MaxGCPauseMillis=200  # Target pause time
-XX:G1HeapRegionSize=16m  # Region size

# JIT compilation
-XX:+TieredCompilation  # Enable tiered compilation
-XX:TieredStopAtLevel=4  # C2 compiler

# Monitoring
-XX:+PrintGCDetails
-XX:+PrintGCTimeStamps
-XX:+HeapDumpOnOutOfMemoryError

// Use StringBuilder for string concatenation
StringBuilder sb = new StringBuilder();
for (String item : items) {
    sb.append(item).append(",");
}
String result = sb.toString();

// Prefer ArrayList over LinkedList for most use cases
List<String> list = new ArrayList<>(expectedSize);

// Use primitive collections to avoid boxing
TIntObjectHashMap<String> map = new TIntObjectHashMap<>();

// Pool expensive objects
ObjectPool<ExpensiveObject> pool = new GenericObjectPool<>(
    new ExpensiveObjectFactory());

// Use final for better JIT optimization
public final class PerformanceOptimized {
    private final int value;
    
    public final int getValue() {
        return value;
    }
}

// Use consistent object shapes for hidden classes
class Point {
  constructor(x, y) {
    this.x = x;  // Always initialize in same order
    this.y = y;
  }
}

// Avoid deoptimizing operations
function optimizedFunction(arr) {
  // V8 can optimize this loop
  let sum = 0;
  for (let i = 0; i < arr.length; i++) {
    sum += arr[i];
  }
  return sum;
}

// Use TypedArrays for numeric data
const buffer = new ArrayBuffer(1024);
const int32View = new Int32Array(buffer);
const float64View = new Float64Array(buffer);

// Prefer const/let over var
const CONSTANT_VALUE = 42;
let mutableValue = 0;

// Use async/await for non-blocking operations
async function fetchData() {
  try {
    const response = await fetch('/api/data');
    return await response.json();
  } catch (error) {
    console.error('Fetch failed:', error);
  }
}

// Code splitting with dynamic imports
const LazyComponent = React.lazy(() => import('./LazyComponent'));

// Tree shaking friendly imports
import { specificFunction } from 'lodash-es';

// Webpack optimization
module.exports = {
  optimization: {
    splitChunks: {
      chunks: 'all',
      cacheGroups: {
        vendor: {
          test: /[\\/]node_modules[\\/]/,
          name: 'vendors',
          chunks: 'all',
        },
      },
    },
  },
};

// Compile with optimization flags
// g++ -O3 -march=native -flto program.cpp

// Help the compiler optimize
inline int fastMultiply(int a, int b) {
    return a * b;
}

// Use const and constexpr
constexpr int BUFFER_SIZE = 1024;
const std::vector<int>& getData() {
    static const std::vector<int> data = {1, 2, 3, 4, 5};
    return data;
}

// SIMD intrinsics for parallel operations
#include <immintrin.h>

void vectorizedAdd(const float* a, const float* b, float* result, size_t n) {
    for (size_t i = 0; i < n; i += 8) {
        __m256 va = _mm256_load_ps(&a[i]);
        __m256 vb = _mm256_load_ps(&b[i]);
        __m256 vr = _mm256_add_ps(va, vb);
        _mm256_store_ps(&result[i], vr);
    }
}

// Use smart pointers for RAII
std::unique_ptr<LargeObject> obj = std::make_unique<LargeObject>();

// Memory pool for frequent allocations
class MemoryPool {
public:
    void* allocate(size_t size) {
        // Custom allocation logic
    }
    
    void deallocate(void* ptr) {
        // Return to pool instead of free
    }
};

// Cache-friendly data structures
struct alignas(64) CacheLineData {
    int values[16];  // Fits in one cache line
};

// Move semantics to avoid copies
class Resource {
public:
    Resource(Resource&& other) noexcept
        : data(std::exchange(other.data, nullptr)) {}
        
    Resource& operator=(Resource&& other) noexcept {
        data = std::exchange(other.data, nullptr);
        return *this;
    }
};

// Use worker pools for CPU-bound tasks
func workerPool(jobs <-chan Job, results chan<- Result) {
    for j := range jobs {
        results <- processJob(j)
    }
}

func main() {
    jobs := make(chan Job, 100)
    results := make(chan Result, 100)
    
    // Start workers
    for w := 0; w < runtime.NumCPU(); w++ {
        go workerPool(jobs, results)
    }
    
    // Send work
    for _, job := range jobList {
        jobs <- job
    }
    close(jobs)
}

// Use sync.Pool for object reuse
var bufferPool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 1024)
    },
}

func processData(data []byte) {
    buf := bufferPool.Get().([]byte)
    defer bufferPool.Put(buf)
    
    // Use buf for processing
}

// Reduce allocations
type StringBuilder struct {
    buf []byte
}

func (sb *StringBuilder) WriteString(s string) {
    sb.buf = append(sb.buf, s...)
}

func (sb *StringBuilder) String() string {
    return string(sb.buf)
}

// Use slices efficiently
func processSlice(data []int) {
    // Pre-allocate with known capacity
    result := make([]int, 0, len(data))
    
    for _, v := range data {
        if v > 0 {
            result = append(result, v*2)
        }
    }
}

// Struct packing for memory efficiency
type OptimizedStruct struct {
    flag   bool    // 1 byte
    id     int32   // 4 bytes
    value  float64 // 8 bytes
    // Total: 16 bytes (with padding)
}

# cProfile for function-level profiling
python -m cProfile -s cumulative script.py

# py-spy for sampling profiler
py-spy record -o profile.svg -- python script.py

# memory_profiler for memory usage
@profile
def memory_intensive_function():
    data = [i for i in range(1000000)]
    return data

# Line profiler for line-by-line analysis
kernprof -l -v script.py

// Built-in pprof profiling
import _ "net/http/pprof"

func main() {
    go func() {
        http.ListenAndServe(":6060", nil)
    }()
    
    // Your application code
}

// CPU profiling
go test -cpuprofile=cpu.prof -bench=.
go tool pprof cpu.prof

// Memory profiling
go test -memprofile=mem.prof -bench=.
go tool pprof mem.prof