79:T493,// Multi-argument memoization with custom key serialization function memoizeMulti( fn: (...args: T) => R, keySerializer: (...args: T) => string = (...args) => JSON.stringify(args) ): (...args: T) => R { const cache = new Map(); return (...args: T): R => { const key = keySerializer(...args); if (cache.has(key)) { return cache.get(key)!; } const result = fn(...args); cache.set(key, result); return result; }; } // Example: Distance calculation between coordinates interface Point { x: number; y: number; } const calculateDistance = memoizeMulti( (p1: Point, p2: Point): number => { console.log('Computing distance...'); return Math.sqrt( Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2) ); }, // Custom serializer for Point objects (p1, p2) => `${p1.x},${p1.y}->${p2.x},${p2.y}` ); // First call computes calculateDistance({x: 0, y: 0}, {x: 3, y: 4}); // Logs "Computing..." // Second call returns cached calculateDistance({x: 0, y: 0}, {x: 3, y: 4}); // No log, returns 57a:T4e6,class LRUCache { private cache = new Map(); constructor(private maxSize: number) {} get(key: K): V | undefined { if (!this.cache.has(key)) return undefined; // Move to end (most recently used) const value = this.cache.get(key)!; this.cache.delete(key); this.cache.set(key, value); return value; } set(key: K, value: V): void { // Remove if exists (to update position) if (this.cache.has(key)) { this.cache.delete(key); } // Evict oldest if at capacity if (this.cache.size >= this.maxSize) { const oldestKey = this.cache.keys().next().value; this.cache.delete(oldestKey); } this.cache.set(key, value); } has(key: K): boolean { return this.cache.has(key); } } function memoizeLRU( fn: (arg: T) => R, maxCacheSize: number = 100 ): (arg: T) => R { const cache = new LRUCache(maxCacheSize); return (arg: T): R => { if (cache.has(arg)) { return cache.get(arg)!; } const result = fn(arg); cache.set(arg, result); return result; }; }7b:T474,class TaxCalculator { private cache = new Map(); constructor( private readonly baseRate: number, private readonly brackets: TaxBracket[] ) {} calculateTax(income: number, deductions: number): number { const key = `${income}:${deductions}`; if (this.cache.has(key)) { return this.cache.get(key)!; } // Expensive calculation with bracket application const taxableIncome = Math.max(0, income - deductions); let tax = 0; let remainingIncome = taxableIncome; for (const bracket of this.brackets) { const taxableInBracket = Math.min( remainingIncome, bracket.ceiling - bracket.floor ); tax += taxableInBracket * bracket.rate; remainingIncome -= taxableInBracket; if (remainingIncome <= 0) break; } this.cache.set(key, tax); return tax; } // Allow cache invalidation when brackets change clearCache(): void { this.cache.clear(); } }7c:T4d3,// TypeScript decorator for method memoization function Memoize() { return function ( target: any, propertyKey: string, descriptor: PropertyDescriptor ) { const originalMethod = descriptor.value; const cacheKey = Symbol(`__memoize_${propertyKey}`); descriptor.value = function (...args: any[]) { if (!this[cacheKey]) { this[cacheKey] = new Map(); } const key = JSON.stringify(args); if (this[cacheKey].has(key)) { return this[cacheKey].get(key); } const result = originalMethod.apply(this, args); this[cacheKey].set(key, result); return result; }; return descriptor; }; } // Usage - clean and declarative class PricingService { @Memoize() calculateDiscount(customerId: string, orderTotal: number): number { // Complex discount logic... return this.fetchCustomerTier(customerId) * orderTotal * 0.1; } @Memoize() async fetchProductPrice(productId: string): Promise { return await this.productRepository.getPrice(productId); } }71:{"json":{"id":"seed_7922be78ef9b17b77c6b55865981f0fb","slug":"caching-in-object-design","category":"System Design LLD","topic":"Caching in Object Design","title":"Caching in Object Design","description":"Master the art of integrating caching directly into object-oriented designs. Learn memoization patterns, lazy loading with caching, computed property caching, and how to treat cache as a first-class collaborator in your system architecture.","difficulty":"INTERMEDIATE","estimatedMinutes":60,"pages":[{"id":"seed_09f42d345b4d721c66ababc3191e6760","title":"Memoization Pattern","order":0,"content":[{"id":"opening-hook","title":"The Cost of Redundant Computation","content":[{"data":{"content":"Every time your application recalculates the same result for the same input, it wastes CPU cycles, increases latency, and burns through resources unnecessarily. In performance-critical systems, this redundancy compounds into observable slowdowns, higher infrastructure costs, and degraded user experience.\n\n**Memoization** is the technique of caching the results of expensive function calls and returning the cached result when the same inputs occur again. It transforms pure functions into self-optimizing units that remember their past computations.\n\nThis isn't merely an optimization trick—it's a fundamental pattern that appears throughout software engineering, from dynamic programming algorithms to React's `useMemo` hook to database query caching. Understanding memoization deeply enables you to identify opportunities for dramatic performance improvements across your entire codebase."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will understand the theoretical foundations of memoization, implement memoization in multiple programming paradigms, recognize when memoization is appropriate versus harmful, and apply advanced memoization strategies in production systems.","variant":"info"},"type":"callout"}]},{"id":"foundations-of-memoization","title":"Foundations of Memoization","content":[{"data":{"content":"Memoization derives from the Latin word *memorandum* (\"to be remembered\"). The term was coined by Donald Michie in 1968 to describe the automatic storage of function results. At its core, memoization exploits a fundamental property of **pure functions**: given the same inputs, they always produce the same outputs.\n\n**The Pure Function Requirement:**\n\nFor memoization to work correctly, the function being memoized must be **referentially transparent**—its output must depend solely on its inputs, with no side effects. Consider these two functions:"},"type":"text"},{"data":{"code":"// ✅ PURE - Safe to memoize\nfunction calculateTax(income: number, rate: number): number {\n return income * rate;\n}\n\n// ❌ IMPURE - Dangerous to memoize\nlet callCount = 0;\nfunction calculateTaxWithSideEffect(income: number, rate: number): number {\n callCount++; // Side effect!\n console.log(`Call #${callCount}`); // Another side effect!\n return income * rate;\n}\n\n// ❌ IMPURE - Output depends on external state\nfunction calculateTaxWithExternalDependency(income: number): number {\n const currentRate = fetchCurrentTaxRate(); // External dependency\n return income * currentRate;\n}","fileName":"pure-vs-impure.ts","showLineNumbers":true},"type":"code"},{"data":{"icon":"AlertCircle","title":"The Stale Cache Problem","content":"Memoizing impure functions creates subtle bugs. If the external state changes but cached results remain, your application serves stale data. This is particularly dangerous because these bugs often appear correct during testing but fail unpredictably in production when underlying assumptions change.","variant":"warning"},"type":"callout"},{"data":{"content":"**The Time-Space Tradeoff:**\n\nMemoization exemplifies the classic time-space tradeoff in computer science. You exchange memory (storing cached results) for time (avoiding recomputation). This tradeoff isn't always favorable:"},"type":"text"},{"data":{"rows":[["Expensive computation, repeated inputs","Dramatic speedup","✅ Strongly recommended"],["Cheap computation, repeated inputs","Marginal speedup, memory overhead","⚠️ Profile first"],["Expensive computation, unique inputs","No speedup, memory bloat","❌ Avoid"],["Recursive algorithms with overlapping subproblems","Exponential → Polynomial","✅ Essential"]],"caption":"When Memoization Helps vs. Hurts","headers":["Scenario","Memoization Effect","Recommendation"]},"type":"table"}],"titleType":"number","titleNumber":1},{"id":"implementing-basic-memoization","title":"Implementing Basic Memoization","content":[{"data":{"content":"The simplest memoization implementation uses a dictionary (hash map) to store computed results. The function input becomes the cache key, and the computed result becomes the value.\n\n**Basic Single-Argument Memoization:**"},"type":"text"},{"data":{"code":"// Generic memoization for single-argument functions\nfunction memoize(fn: (arg: T) => R): (arg: T) => R {\n const cache = new Map();\n \n return (arg: T): R => {\n // Check cache first\n if (cache.has(arg)) {\n return cache.get(arg)!;\n }\n \n // Compute and cache result\n const result = fn(arg);\n cache.set(arg, result);\n return result;\n };\n}\n\n// Example: Expensive Fibonacci calculation\nfunction slowFibonacci(n: number): number {\n if (n <= 1) return n;\n return slowFibonacci(n - 1) + slowFibonacci(n - 2);\n}\n\n// Memoized version - transforms O(2^n) to O(n)\nconst fastFibonacci = memoize(function fib(n: number): number {\n if (n <= 1) return n;\n return fastFibonacci(n - 1) + fastFibonacci(n - 2);\n});\n\n// Performance comparison\nconsole.time('slow');\nslowFibonacci(40); // Takes ~1-2 seconds\nconsole.timeEnd('slow');\n\nconsole.time('fast');\nfastFibonacci(40); // Takes <1 millisecond\nconsole.timeEnd('fast');","fileName":"basic-memoization.ts","showLineNumbers":true},"type":"code"},{"data":{"content":"**Multi-Argument Memoization:**\n\nWhen functions accept multiple arguments, creating cache keys becomes more complex. You must serialize arguments into a consistent key format:"},"type":"text"},{"data":{"code":"$79","fileName":"multi-arg-memoization.ts","showLineNumbers":true},"type":"code"},{"data":{"icon":"Lightbulb","title":"Key Serialization Pitfalls","content":"JSON.stringify doesn't guarantee consistent key ordering for objects! The keys {a:1, b:2} and {b:2, a:1} stringify differently. For object arguments, either sort keys before serializing or use a deterministic serialization library like fast-json-stable-stringify.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":2},{"id":"advanced-memoization-strategies","title":"Advanced Memoization Strategies","content":[{"data":{"content":"Production systems require more sophisticated memoization strategies that handle cache size limits, expiration, and memory pressure.\n\n**LRU (Least Recently Used) Memoization:**\n\nUnbounded caches grow indefinitely, eventually consuming all available memory. LRU caching maintains a fixed-size cache by evicting the least recently accessed entries:"},"type":"text"},{"data":{"code":"$7a","fileName":"lru-memoization.ts","showLineNumbers":true},"type":"code"},{"data":{"content":"**Time-Based Expiration (TTL Memoization):**\n\nFor data that becomes stale over time, combine memoization with time-to-live semantics:"},"type":"text"},{"data":{"code":"interface CacheEntry {\n value: T;\n expiresAt: number;\n}\n\nfunction memoizeWithTTL(\n fn: (arg: T) => R,\n ttlMs: number\n): (arg: T) => R {\n const cache = new Map>();\n \n return (arg: T): R => {\n const now = Date.now();\n const entry = cache.get(arg);\n \n // Return cached if valid and not expired\n if (entry && entry.expiresAt > now) {\n return entry.value;\n }\n \n // Compute, cache with expiration\n const result = fn(arg);\n cache.set(arg, {\n value: result,\n expiresAt: now + ttlMs\n });\n return result;\n };\n}\n\n// Example: Cache user data for 5 minutes\nconst getUserProfile = memoizeWithTTL(\n async (userId: string) => {\n return await database.users.findById(userId);\n },\n 5 * 60 * 1000 // 5 minutes\n);","fileName":"ttl-memoization.ts","showLineNumbers":true},"type":"code"}],"titleType":"number","titleNumber":3},{"id":"memoization-in-oop","title":"Memoization in Object-Oriented Design","content":[{"data":{"content":"In object-oriented systems, memoization integrates naturally with class designs. Instance-level memoization caches results per object, while class-level memoization shares caches across all instances.\n\n**Instance-Level Memoization:**"},"type":"text"},{"data":{"code":"$7b","fileName":"instance-memoization.ts","showLineNumbers":true},"type":"code"},{"data":{"content":"**Decorator-Based Memoization:**\n\nModern languages support decorators that make memoization declarative and clean:"},"type":"text"},{"data":{"code":"$7c","fileName":"decorator-memoization.ts","showLineNumbers":true},"type":"code"}],"titleType":"number","titleNumber":4},{"id":"pitfalls-and-best-practices","title":"Common Pitfalls and Best Practices","content":[{"data":{"items":["**Memoizing impure functions** — Functions with side effects or external dependencies produce incorrect cached results when underlying state changes.","**Unbounded cache growth** — Without size limits, memoization caches grow indefinitely. In long-running processes, this causes memory exhaustion and crashes.","**Object reference keys** — Using objects as cache keys often fails because object identity differs even when values are identical. Always serialize or hash object keys.","**Ignoring async considerations** — Naive memoization of async functions can cause thundering herd problems where multiple callers trigger the expensive operation before the first result is cached.","**Over-memoization** — Memoizing cheap functions adds overhead without benefit. The cache lookup and storage may cost more than recomputation."],"title":{"icon":"AlertCircle","text":"Memoization Anti-Patterns to Avoid","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"items":["**Profile before memoizing** — Measure actual performance impact. Not all repeated computations benefit from caching overhead.","**Set appropriate cache sizes** — Choose limits based on memory budgets and access patterns. Monitor cache hit rates.","**Implement cache invalidation** — Provide mechanisms to clear caches when underlying data changes.","**Use weak references for large objects** — WeakMap prevents memory leaks when cached keys are garbage collected.","**Handle async correctly** — Cache the Promise itself, not just the resolved value, to prevent duplicate in-flight requests."],"title":{"icon":"CheckCircle","text":"Memoization Best Practices","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now understand the memoization pattern deeply—from its theoretical foundations in pure functions to practical implementation strategies including LRU and TTL caching. Next, we'll explore lazy loading with caching, combining deferred computation with result caching for optimal resource utilization.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":5}],"isLocked":false},{"id":"seed_b9abc3b9e0abedc0374238190d1f7902","title":"Lazy Loading with Caching","order":1,"content":null,"isLocked":true},{"id":"seed_03d34df9645f45dd975c2932c3dfa558","title":"Caching Computed Properties","order":2,"content":null,"isLocked":true},{"id":"seed_d13ce4a3b452a60e24d4e1855270eed4","title":"Cache as Collaborator","order":3,"content":null,"isLocked":true}]}}