Emem Isaac's Musings

Why caching matters

Caching improves performance by storing expensive-to-produce results (computed values, database query results, HTTP responses, or files) close to where they are needed. This reduces latency, lowers load on origin systems, and can drastically cut costs.

Types of caching

In-memory — fast, local to process (e.g., MemoryCache, Node process memory).
Distributed — shared across processes/servers (e.g., Redis, Memcached).
HTTP / CDN — cache at edge, near clients (e.g., Cloudflare, Fastly).
Database query cache — store query results or materialized views.

When not to cache

Don't cache rapidly changing data, highly personalized data (unless keyed per user), or data where stale reads would be harmful without careful invalidation. Monitor cache hit ratios and fall back safely when a cache is unavailable.

Implementation examples

Each example includes a short explanation and a minimal, copyable snippet. Characters that could break JSX are safely escaped by rendering the snippets inside a JavaScript string using {`...`} in this TSX file.

1) ASP.NET Core (In-memory + Distributed Redis)

Explanation: Use IMemoryCache for single-process caching and IDistributedCache (backed by Redis) for multi-instance stores. Use sliding/absolute expirations and cache invalidation when data changes.

// Startup.cs (ConfigureServices)
services.AddMemoryCache();
services.AddStackExchangeRedisCache(options => {
    options.Configuration = "localhost:6379"; // adapt for production
    options.InstanceName = "MyApp:";
});

// Example service
public class ProductService {
    private readonly IMemoryCache _memoryCache;
    private readonly IDistributedCache _distributedCache;

    public ProductService(IMemoryCache memoryCache, IDistributedCache distributedCache) {
        _memoryCache = memoryCache;
        _distributedCache = distributedCache;
    }

    public async Task<Product> GetProductAsync(int id) {
        var memKey = $"product:mem:{id}";
        if (_memoryCache.TryGetValue(memKey, out Product cached)) return cached;

        var distKey = $"product:dist:{id}";
        var distBytes = await _distributedCache.GetAsync(distKey);
        if (distBytes != null) {
            var distProduct = JsonSerializer.Deserialize<Product>(distBytes);
            _memoryCache.Set(memKey, distProduct, TimeSpan.FromSeconds(30));
            return distProduct;
        }

        // expensive DB call
        var product = await LoadFromDatabaseAsync(id);
        _memoryCache.Set(memKey, product, TimeSpan.FromSeconds(30));
        var bytes = JsonSerializer.SerializeToUtf8Bytes(product);
        await _distributedCache.SetAsync(distKey, bytes, new DistributedCacheEntryOptions {
            AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5)
        });
        return product;
    }
}

2) Spring Boot (Cache Abstraction + Redis)

Explanation: Spring Cache abstraction lets you annotate methods with @Cacheable. Back it with Redis for distributed caching.

// build.gradle (dependencies)
// implementation 'org.springframework.boot:spring-boot-starter-data-redis'
// implementation 'org.springframework.boot:spring-boot-starter-cache'

// Application.java
@EnableCaching
@SpringBootApplication
public class Application { }

// ProductService.java
@Service
public class ProductService {
    @Cacheable(value = "products", key = "#id")
    public Product getProduct(Long id) {
        // expensive DB call
        return productRepository.findById(id).orElse(null);
    }
}

// application.properties
spring.cache.type=redis
spring.redis.host=localhost
spring.redis.port=6379

3) Express (Node) — In-memory and Redis

Explanation: For small apps, use a process-local LRU cache (e.g., lru-cache). For scale, use Redis. Always consider TTL and cache stampede protection.

// npm install express ioredis lru-cache
const express = require('express');
const LRU = require('lru-cache');
const Redis = require('ioredis');

const app = express();
const memCache = new LRU({ max: 500, ttl: 1000 * 30 });
const redis = new Redis();

app.get('/product/:id', async (req, res) => {
  const id = req.params.id;
  const memKey = `product:mem:${id}`;
  if (memCache.has(memKey)) return res.json(memCache.get(memKey));

  const distKey = `product:dist:${id}`;
  const dist = await redis.get(distKey);
  if (dist) {
    const parsed = JSON.parse(dist);
    memCache.set(memKey, parsed);
    return res.json(parsed);
  }

  // simulate DB
  const product = await loadFromDb(id);
  memCache.set(memKey, product);
  await redis.set(distKey, JSON.stringify(product), 'EX', 300);
  res.json(product);
});

4) Next.js (Edge / ISR / API caching)

Explanation: Next.js supports ISR (Incremental Static Regeneration), static generation with revalidation, and standard API route caching. Use revalidate in getStaticProps or HTTP cache headers in API routes.

// pages/products/[id].js (getStaticProps ISR)
export async function getStaticProps(context) {
  const id = context.params.id;
  const product = await fetchProductFromDb(id);
  return {
    props: { product },
    revalidate: 60 // seconds — regenerate at most every 60s
  };
}

// API route with Cache-Control
export default async function handler(req, res) {
  const product = await fetchProductFromDb(req.query.id);
  res.setHeader('Cache-Control', 's-maxage=60, stale-while-revalidate=30');
  res.status(200).json(product);
}

5) Flask (Python) — Simple cache + Redis

Explanation: Use Flask-Caching for local or Redis-backed caches. Cache function results or view responses.

# pip install Flask Flask-Caching redis
from flask import Flask, jsonify
from flask_caching import Cache

app = Flask(__name__)
app.config['CACHE_TYPE'] = 'RedisCache'
app.config['CACHE_REDIS_URL'] = 'redis://localhost:6379/0'
cache = Cache(app)

@cache.cached(timeout=300, key_prefix='product_%s')
def get_product(id):
    # expensive database call
    return load_from_db(id)

@app.route('/product/<int:id>')
def product_view(id):
    product = get_product(id)
    return jsonify(product)

6) Laravel (PHP) — Cache facade

Explanation: Laravel's cache layer supports many backends (file, redis, memcached). Use Cache::remember() to fetch-or-store logic with TTL.

// config/cache.php -> set redis
// Example controller
use Illuminate\Support\Facades\Cache;

public function show($id) {
    $cacheKey = "product:{$id}";
    $product = Cache::remember($cacheKey, 300, function() use ($id) {
        return Product::find($id);
    });
    return response()->json($product);
}

Strategies and considerations

Cache keys: Use predictable, namespaced keys (e.g., product:dist:123).
TTL: Set appropriate time-to-live. Short TTLs for fast-changing data, longer for stable data.
Invalidation: Evict or update caches after writes. Use message buses (e.g., Redis pub/sub) to invalidate distributed caches across nodes.
Cache stampede: Protect with locks or use "request coalescing"—only one process fetches the origin while others wait or serve stale.
Stale-while-revalidate: Serve stale content while revalidating in background to maintain low latency.
Monitoring: Track hit/miss rates, latency, and eviction rates.
Security: Never cache sensitive personal data unless encrypted and properly keyed.

A common pattern is a two-layer cache: a small, fast in-memory layer for repeated reads in the same process, backed by a distributed cache like Redis for sharing between instances.

Conclusion

Caching is one of the most effective ways to reduce latency and system load. Start by identifying expensive operations, choose an appropriate cache type, and implement a clear strategy for keys, TTLs, and invalidation. Test and monitor impact, and remember that caching introduces complexity — prioritize correctness over premature optimization.

Happy caching — and ship fast, serve fast!

Isaac.

Implement Caching for Performance Optimization