How V8’s generational mark-and-sweep collector actually works, the 4 classic leak patterns in SPAs (forgotten listeners, over-capturing closures, unbounded caches, detached DOM), and how to find a real leak with Chrome DevTools heap snapshot comparison.
JavaScript Memory and Garbage Collection: Why Your SPA Leaks Read More »
Build a Promise from scratch in 60 lines. State machine (pending → fulfilled / rejected), why callbacks run as microtasks, how chaining works (then returns a new Promise that adopts the inner result’s state), catch/finally as sugar, and how async/await desugars to .then.
The event loop coordinates JavaScript’s single call stack with the microtask and macrotask queues. Why Promise.then always runs before setTimeout(0), what counts as a microtask vs macrotask, how rendering fits in, microtask starvation, and the await-in-a-loop trap.
The JavaScript Event Loop, Microtasks vs Macrotasks (with Timing Examples) Read More »
JavaScript coercion isn’t chaos — it’s a small set of rules. To-number/to-string/to-boolean tables, `==` vs `===`, why `[] == ![]` is `true` (walked step by step), the 7 falsy values, when `== null` is the right tool, and `Object.is`.
JavaScript Type Coercion and Equality: Why `[] == ![]` is `true` Read More »
`this` follows 5 binding rules: default, implicit, explicit, new, and arrow (lexical). The one-sentence summary, the precedence ladder, and every gotcha — losing `this` in callbacks, class methods, forEach, setTimeout, and destructured methods — solved with arrow functions or bind.
The JavaScript `this` Keyword: All 5 Binding Rules in One Place Read More »
Closures are simply lexical scope + first-class functions. A function bundled with a reference to its outer environment that keeps captured variables alive after the outer function returns. With 7 production patterns: private state, factories, memoization, debounce, iterators, once, and the module pattern.
JavaScript Closures: The Definitive Guide (with 7 Production Patterns) Read More »
Lexical scope means variable accessibility is fixed by where the code is written, not where it is called from. The scope chain, block vs function vs module scope, shadowing, and the lookup mechanism that makes closures possible — explained step by step.
JavaScript Lexical Scope: How the Engine Resolves Every Variable Read More »
Hoisting in JavaScript is NOT “declarations being moved to the top of the file.” It’s the engine reserving memory before your code runs — and how each declaration type gets initialized differently. var, let, const, function, and class hoisting explained with the temporal dead zone, block scope, and 4 common gotchas.
JavaScript Hoisting Explained: var, let, const, and Functions in 2026 Read More »
Every JavaScript bug ultimately traces back to one mental model — the execution context and the call stack. Here’s the picture every JS developer should carry in their head: what an execution context holds, how the call stack pushes and pops, what stack overflow really is, and how async code fits in.
JavaScript Execution Context and the Call Stack: The Mental Model You Need Read More »
An opinion piece on why Model Context Protocol overtook vendor-specific AI plugin stores in 2026 — the structural reasons standards beat marketplaces, what it means for developers, and where this dynamic plays out next.
Why Model Context Protocol Is Eating “AI Plugins” in 2026 Read More »