🟨 JavaScript & TypeScript Core

Why a function remembers variables from where it was defined — and how scope, hoisting, and the TDZ actually work.

The four rules that decide what `this` is at call time — and why arrow functions ignore them.

How property lookup walks [[Prototype]] up to null, and why class is just sugar over it.

Why the output is A, D, C, B — how the call stack, microtask queue, and macrotask queue decide async ordering.

States, chaining, error handling, and the concurrency helpers — plus how await maps back to the event loop.

Why == is dangerous, how JS coerces types automatically, and the truthy/falsy rules that trip up even experienced devs.

Two patterns every frontend engineer must be able to implement cold: what they do, when each fits, and the code.

Pure functions, immutability, currying, partial application, and function composition — the functional toolkit asked at mid-senior interviews.

Symbol.iterator, the iterator protocol, generator functions, lazy sequences, and async generators — the machinery behind for...of and spread.

Static vs dynamic, live bindings vs copies, tree shaking, circular dependencies — what every senior JS dev must know about the module system.

The TS features that separate shallow knowledge from real depth: generics, the built-in utility types, type narrowing, and mapped/conditional types.

Error types, try/catch/finally semantics, async error propagation, custom error classes, and the patterns that prevent silent failures.

Observer, Module, Singleton, Factory, and Strategy — the classic patterns reframed for modern JS/TS, with real-world React/Node parallels.

Shallow vs deep clone, Object.freeze, structuredClone, WeakMap/WeakSet for memory-safe caching, and how the garbage collector works.