JavaScript
Closures, prototypes, event loop, async, currying, generators, proxies
Egg
Fundamentals
Hatchling
Intermediate
The JavaScript Event Loop
Understanding the event loop is what separates engineers who debug from engineers who architect. Master the execution model that powers every line of JS.
Prototypes & Inheritance
JavaScript's prototype chain is the engine beneath classes, Object.create, and half the 'magic' in the language. Master the mental model interviewers expect.
Prototypes & The JavaScript Object Model
JavaScript doesn't have classical inheritance â it has prototypal delegation. Understanding this distinction is what makes the difference between using the language and understanding it.
The this Keyword & Execution Binding
this is the only dynamically scoped construct in JavaScript. Mastering its four binding rules eliminates an entire class of bugs.
Functional Programming Patterns in JavaScript
Pure functions, immutability, composition, currying â functional patterns that make code predictable, testable, and maintainable at scale.
ES Modules, Proxy, Generators & Modern JavaScript
Beyond ES6 basics. The modern JavaScript features that power frameworks, tooling, and advanced patterns â from modules to metaprogramming.
Error Handling & Debugging Patterns
Robust error handling separates production-grade code from demo code. Understanding error propagation, custom errors, async error boundaries, and debugging strategies is essential for senior engineers.
Event Propagation, Bubbling & Delegation
Events don't just fire on the target â they travel through the entire DOM tree. Understanding capturing, bubbling, and delegation is critical for building performant event-driven UIs.
DOM, BOM & Web APIs
The DOM is your application's interface to the rendered page. The BOM gives you browser-level control. Web APIs extend JavaScript beyond the language spec. Together they form the runtime platform.
Data Types, Shallow/Deep Copy & Mutability
Primitives are immutable. Objects are references. Misunderstanding this distinction causes some of the most insidious bugs in JavaScript â stale state, unintended mutations, and broken equality checks.
Callbacks, Promises & Async/Await
The evolution from callback hell to promises to async/await isn't just syntax sugar â each model has different error handling, composition, and cancellation characteristics.
Dinosaur
Advanced
Closures, Scope & Execution Context
Closures aren't a feature â they're a consequence of how JavaScript scoping works. Understanding the execution context model unlocks debugging, hooks, and module patterns.
The Event Loop & Async Execution Model
JavaScript is single-threaded but never blocking. The event loop is the scheduling algorithm behind every setTimeout, every Promise, and every React state update.
Async Patterns
Promises, async/await, and concurrency control are table stakes for senior frontend roles. Know the patterns that separate production code from tutorial code.
Async Patterns & Concurrency Control
Promises and async/await are just the beginning. Production code needs retry logic, cancellation, rate limiting, and structured concurrency. This is where senior engineers live.
Memory Management & Garbage Collection
Memory leaks in JavaScript are silent killers. Senior engineers understand the GC algorithm, common leak patterns, and the tools to detect them before users notice.
Currying & Partial Application
Currying transforms a multi-argument function into a chain of single-argument functions. It's the backbone of composition, reusable utilities, and functional middleware.
Generators, Iterators & Symbols
Generators produce values on demand. Iterators define traversal protocols. Symbols create invisible, collision-free property keys. Together they power async flows, custom collections, and metaprogramming.
JavaScript Design Patterns
Design patterns are battle-tested solutions to recurring problems. Singleton, Factory, Observer, Proxy, Module â knowing when and why to apply each one is what separates code that works from code that scales.
Apex
Architect