What are the performance optimization techniques for Deno?

Performance optimization in Deno is crucial for building high-performance applications. Understanding Deno's performance characteristics and optimization techniques can help developers fully leverage its potential.

Performance Characteristics Overview

Deno is built on Rust and the V8 engine, providing a solid performance foundation. Through proper optimization strategies, application performance can be further enhanced.

Startup Performance Optimization

1. Reduce Dependency Loading

typescript
// Bad practice: Load all dependencies at the top level
import { heavyModule1 } from "./heavy-module-1.ts";
import { heavyModule2 } from "./heavy-module-2.ts";
import { heavyModule3 } from "./heavy-module-3.ts";

// Good practice: Load on demand
async function processWithHeavyModule1() {
  const { heavyModule1 } = await import("./heavy-module-1.ts");
  return heavyModule1.process();
}

2. Use Caching

typescript
// Cache compilation results
const cache = new Map<string, any>();

async function getCachedData(key: string, fetcher: () => Promise<any>) {
  if (cache.has(key)) {
    return cache.get(key);
  }
  
  const data = await fetcher();
  cache.set(key, data);
  return data;
}

3. Warm Up Cache

typescript
// Warm up cache on application startup
async function warmupCache() {
  await Promise.all([
    getCachedData("config", loadConfig),
    getCachedData("translations", loadTranslations),
  ]);
}

warmupCache().then(() => {
  console.log("Cache warmed up, ready to serve");
});

Runtime Performance Optimization

1. Use Efficient Data Structures

typescript
// Use Map instead of Object for frequent lookups
const userMap = new Map<string, User>();

// Fast lookup
function getUser(id: string): User | undefined {
  return userMap.get(id);
}

// Use Set for fast existence checks
const activeUsers = new Set<string>();

function isActiveUser(id: string): boolean {
  return activeUsers.has(id);
}

2. Avoid Unnecessary Computations

typescript
// Use memoization
function memoize<T extends (...args: any[]) => any>(fn: T): T {
  const cache = new Map<string, ReturnType<T>>();
  
  return ((...args: Parameters<T>) => {
    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;
}

// Use memoized function
const expensiveCalculation = memoize((n: number): number => {
  console.log(`Calculating for ${n}`);
  let result = 0;
  for (let i = 0; i < n * 1000000; i++) {
    result += i;
  }
  return result;
});

// First call calculates
console.log(expensiveCalculation(100));

// Second call uses cache
console.log(expensiveCalculation(100));

3. Batch Processing

typescript
// Batch database operations
async function batchInsert(items: Item[]): Promise<void> {
  const batchSize = 100;
  
  for (let i = 0; i < items.length; i += batchSize) {
    const batch = items.slice(i, i + batchSize);
    await insertBatch(batch);
  }
}

// Batch API requests
async function batchFetch(urls: string[]): Promise<Response[]> {
  const batchSize = 10;
  const results: Response[] = [];
  
  for (let i = 0; i < urls.length; i += batchSize) {
    const batch = urls.slice(i, i + batchSize);
    const batchResults = await Promise.all(
      batch.map(url => fetch(url))
    );
    results.push(...batchResults);
  }
  
  return results;
}

Memory Optimization

1. Avoid Memory Leaks

typescript
// Clean up resources promptly
class ResourceManager {
  private resources: Set<Disposable> = new Set();
  
  register(resource: Disposable) {
    this.resources.add(resource);
  }
  
  cleanup() {
    for (const resource of this.resources) {
      resource.dispose();
    }
    this.resources.clear();
  }
}

// Use WeakMap to avoid strong references
const weakCache = new WeakMap<object, any>();

function cacheData(obj: object, data: any) {
  weakCache.set(obj, data);
}

2. Stream Large Files

typescript
// Use streaming to process large files, avoid loading all into memory
import { readableStreamFromIterable } from "https://deno.land/std@0.208.0/streams/mod.ts";

async function processLargeFile(filePath: string) {
  const file = await Deno.open(filePath);
  const reader = file.readable.getReader();
  
  const buffer = new Uint8Array(1024 * 1024); // 1MB buffer
  
  while (true) {
    const { done, value } = await reader.read(buffer);
    
    if (done) break;
    
    // Process data chunk
    processDataChunk(value);
  }
  
  file.close();
}

3. Object Pool Pattern

typescript
// Object pool to reuse objects, reduce GC pressure
class ObjectPool<T> {
  private pool: T[] = [];
  private factory: () => T;
  private reset: (obj: T) => void;
  
  constructor(
    factory: () => T,
    reset: (obj: T) => void,
    initialSize: number = 10
  ) {
    this.factory = factory;
    this.reset = reset;
    
    for (let i = 0; i < initialSize; i++) {
      this.pool.push(factory());
    }
  }
  
  acquire(): T {
    return this.pool.pop() || this.factory();
  }
  
  release(obj: T) {
    this.reset(obj);
    this.pool.push(obj);
  }
}

// Use object pool
const bufferPool = new ObjectPool(
  () => new Uint8Array(1024 * 1024),
  (buffer) => buffer.fill(0),
  5
);

async function processData() {
  const buffer = bufferPool.acquire();
  
  try {
    // Use buffer to process data
    await processWithBuffer(buffer);
  } finally {
    bufferPool.release(buffer);
  }
}

Concurrency Performance Optimization

1. Use Workers for Parallel Processing

typescript
// Use Workers for CPU-intensive tasks
import { WorkerPool } from "./worker-pool.ts";

const pool = new WorkerPool("./data-processor.ts", 4);

async function parallelProcess(data: any[]) {
  const promises = data.map(item => pool.execute(item));
  return Promise.all(promises);
}

2. Control Concurrency

typescript
// Control concurrent requests
class ConcurrencyController {
  private running: Set<Promise<any>> = new Set();
  private maxConcurrent: number;
  
  constructor(maxConcurrent: number) {
    this.maxConcurrent = maxConcurrent;
  }
  
  async execute<T>(task: () => Promise<T>): Promise<T> {
    while (this.running.size >= this.maxConcurrent) {
      await Promise.race(this.running);
    }
    
    const promise = task().finally(() => {
      this.running.delete(promise);
    });
    
    this.running.add(promise);
    return promise;
  }
}

const controller = new ConcurrencyController(10);

async function fetchWithConcurrency(urls: string[]) {
  return Promise.all(
    urls.map(url => controller.execute(() => fetch(url)))
  );
}

3. Use Async Iterators

typescript
// Use async iterators for streaming data
async function* processStream(stream: ReadableStream<Uint8Array>) {
  const reader = stream.getReader();
  
  while (true) {
    const { done, value } = await reader.read();
    
    if (done) break;
    
    yield processChunk(value);
  }
}

// Use async iterator
for await (const result of processStream(dataStream)) {
  console.log(result);
}

I/O Performance Optimization

1. Use Async I/O

typescript
// Always use async I/O operations
async function readConfig(): Promise<Config> {
  const content = await Deno.readTextFile("config.json");
  return JSON.parse(content);
}

// Batch file operations
async function batchReadFiles(filePaths: string[]): Promise<Map<string, string>> {
  const results = new Map<string, string>();
  
  await Promise.all(
    filePaths.map(async (path) => {
      const content = await Deno.readTextFile(path);
      results.set(path, content);
    })
  );
  
  return results;
}

2. Use Caching Strategies

typescript
// LRU cache implementation
class LRUCache<K, V> {
  private cache: Map<K, V>;
  private maxSize: number;
  
  constructor(maxSize: number) {
    this.cache = new Map();
    this.maxSize = maxSize;
  }
  
  get(key: K): V | undefined {
    const value = this.cache.get(key);
    
    if (value !== undefined) {
      // Re-insert to update access order
      this.cache.delete(key);
      this.cache.set(key, value);
    }
    
    return value;
  }
  
  set(key: K, value: V): void {
    if (this.cache.has(key)) {
      this.cache.delete(key);
    } else if (this.cache.size >= this.maxSize) {
      // Delete oldest item
      const firstKey = this.cache.keys().next().value;
      this.cache.delete(firstKey);
    }
    
    this.cache.set(key, value);
  }
}

// Use LRU cache
const configCache = new LRUCache<string, Config>(100);

async function getConfigWithCache(key: string): Promise<Config> {
  const cached = configCache.get(key);
  
  if (cached) {
    return cached;
  }
  
  const config = await loadConfig(key);
  configCache.set(key, config);
  return config;
}

3. HTTP Performance Optimization

typescript
// Use connection pooling
import { serve } from "https://deno.land/std@0.208.0/http/server.ts";

const handler = async (req: Request): Promise<Response> => {
  // Enable compression
  const acceptEncoding = req.headers.get("accept-encoding");
  
  let body = await getResponseBody();
  
  if (acceptEncoding?.includes("gzip")) {
    body = await compressGzip(body);
    return new Response(body, {
      headers: {
        "Content-Encoding": "gzip",
        "Content-Type": "application/json",
      },
    });
  }
  
  return new Response(body, {
    headers: { "Content-Type": "application/json" },
  });
};

// Use HTTP/2
await serve(handler, {
  port: 8000,
  alpnProtocols: ["h2"],
});

Monitoring and Debugging

1. Performance Monitoring

typescript
// Performance monitoring tool
class PerformanceMonitor {
  private metrics: Map<string, number[]> = new Map();
  
  record(operation: string, duration: number) {
    if (!this.metrics.has(operation)) {
      this.metrics.set(operation, []);
    }
    
    this.metrics.get(operation)!.push(duration);
  }
  
  getStats(operation: string) {
    const durations = this.metrics.get(operation);
    
    if (!durations || durations.length === 0) {
      return null;
    }
    
    const sorted = [...durations].sort((a, b) => a - b);
    
    return {
      count: durations.length,
      min: sorted[0],
      max: sorted[sorted.length - 1],
      avg: durations.reduce((a, b) => a + b, 0) / durations.length,
      p50: sorted[Math.floor(sorted.length * 0.5)],
      p95: sorted[Math.floor(sorted.length * 0.95)],
      p99: sorted[Math.floor(sorted.length * 0.99)],
    };
  }
}

// Use performance monitoring
const monitor = new PerformanceMonitor();

async function measurePerformance<T>(
  operation: string,
  fn: () => Promise<T>
): Promise<T> {
  const start = performance.now();
  
  try {
    return await fn();
  } finally {
    const duration = performance.now() - start;
    monitor.record(operation, duration);
  }
}

// Usage example
await measurePerformance("database-query", async () => {
  return await db.query("SELECT * FROM users");
});

2. Memory Profiling

typescript
// Memory usage monitoring
function getMemoryUsage() {
  return {
    rss: Deno.memoryUsage().rss / 1024 / 1024, // MB
    heapTotal: Deno.memoryUsage().heapTotal / 1024 / 1024,
    heapUsed: Deno.memoryUsage().heapUsed / 1024 / 1024,
    external: Deno.memoryUsage().external / 1024 / 1024,
  };
}

// Periodically report memory usage
setInterval(() => {
  const usage = getMemoryUsage();
  console.log("Memory usage:", usage);
}, 60000); // Every minute

Best Practices

1. Measure first: Measure performance bottlenecks before optimizing
2. Progressive optimization: Optimize one aspect at a time, avoid over-optimization
3. Use caching: Reasonably use caching to reduce redundant calculations
4. Async first: Always use async I/O operations
5. Batch processing: Batch operations to reduce overhead
6. Resource management: Release unused resources promptly
7. Continuous monitoring: Continuously monitor performance metrics

Deno provides a solid performance foundation, and through proper optimization strategies, high-performance applications can be built. Remember, premature optimization is the root of all evil, always optimize based on actual measurements.