Master JavaScript through organized learning paths. Explore concepts by topic.
Why JS is the way it is
Building a mental model for code execution
What programs are actually made of
The two kinds of code
Engineers spend 80% of time reading, not writing
Hypothesis → Test → Learn cycle
var, let, and const explained
Primitives vs Objects
Arithmetic, comparison, and logical
Declarations, expressions, and arrows
if, switch, and ternary
for, while, and for...of
Lists of values and array methods
Methods that modify arrays in place
Declarative array processing methods
Search arrays by value or predicate
Non-mutating array transformations
Key-value pairs and dot notation
String primitives, immutability, and built-in methods
== vs === vs Object.is and their edge cases
Parsing, stringifying, and JSON limitations
Iterating keys vs values and when to use each
typeof quirks, Array.isArray, and type checking strategies
&& and || return values, not just booleans
Where variables live and are accessible
How var, let, and const are hoisted differently
Why function declarations can be called before definition
Why you cannot access let/const before declaration
Scope is determined at write time, not runtime
Functions that remember their outer scope
Data privacy, factories, and stateful functions
Why var + closures in loops cause bugs
Functions passed as arguments to other functions
Why nested callbacks become unmaintainable
new Promise() and the executor function
Sequential async operations in a flat structure
try/catch with async/await
Running async operations in parallel with Promise.all
Cancel async operations and prevent memory leaks
Transform arrays into any value type
Correct array sorting with comparators
Non-mutating array operations
How JS objects inherit from other objects
How JS finds properties on the chain
Checking prototype chain membership
What class syntax desugars to
Constructor function inheritance patterns
Security vulnerability via prototype manipulation
Private fields, statics, mixins, and advanced patterns
Extract values into variables concisely
Expand arrays and objects with ...
Collect remaining arguments into array
String interpolation with backticks
Safe property access with ?.
Default values for null/undefined only
??=, ||=, &&= operators
Unique identifiers and well-known symbols
Shallow vs deep copy and structuredClone()
Process template strings with custom functions
How JS tracks function execution
The components of the JS runtime
Queue for setTimeout, setInterval, I/O callbacks
Higher priority than macrotasks
The complete event loop iteration
When tasks block the event loop
Keyed collections and unique value sets
Weak references for GC-friendly object metadata
Property access control and computed properties
Functions that remember their scope
Context binding rules
JavaScript inheritance mechanism
Functions that call themselves
From globals to ES Modules
From callbacks to async/await
Async operations and combinators
Curry, pipe, compose, and middleware
Debounce and throttle patterns
Cache function results
Functions that take or return functions
Iteration protocol, generators, and lazy evaluation
Pattern matching for strings
Fixing function arguments with closures
How async JavaScript works
From jQuery to Zustand
From script tags to Vite
Intercept and customize object operations
Iterate over asynchronous data sources
Stack vs Heap and garbage collection
JIT compilation and optimization
Libuv phases and async patterns
Efficient data processing
Node.js convention: callback(err, result)
How browsers render pages
Multi-threading in the browser
From static HTML to modern SSR/SSG
How the browser handles user interactions
Modern HTTP requests with Promises
Client-side key-value storage in the browser