The JavaScript curriculum
Eighteen modules, 98 lessons, every one with live code, a graded exercise and a quiz.
Foundations: How JavaScript Runs
What actually happens between saving a file and seeing output: which engine reads your code, which host hands it superpowers, how one thread schedules everything, and how to read the first error you cause instead of guessing at it.
Values, Types and Variables
JavaScript has seven primitive types plus objects, and most beginner bugs come from mixing them up. Learn what each type is, when a value is copied and when it is shared, how var, let and const really differ, and where numbers, strings and null will surprise you.
Operators, Coercion and Equality
The rules behind every expression you write: what each operator does, the exact conversions JavaScript performs when types do not match, why == and === disagree, and how truthiness plus the nullish operators decide which default a value gets.
Control Flow
How a program decides what to do next: branching with if and switch, choosing a value with the ternary, repeating work with the four loop forms, and steering a loop with break, continue and labels. Plus when to delete a branch entirely and use a lookup.
Functions
The unit you will write most often. Four ways to declare one and what each does at parse time, how arguments really arrive, what comes back when you forget to return, and the three ideas that turn functions into building blocks: higher order use, recursion and purity.
Scope and Closures
Where a name is visible, why a function remembers the variables it was written next to, and how that single fact powers private state, memoisation, debouncing and every module pattern in JavaScript.
Objects
Objects are where your data lives. Read and write properties, destructure them, copy them without secretly sharing nested state, describe them with accessors and descriptors, freeze them, serialise them to JSON, and reach into them safely when parts may be missing.
Arrays and Iteration
Arrays are where most JavaScript work happens. Build them, change them safely, describe transformations with map, filter and reduce instead of loops, sort without the classic traps, and reach for Set, Map and iterators when a plain array stops being the right shape.
Strings, Numbers, Dates and Regex
The data types every application actually formats and parses. Slice and build strings without fighting immutability, write tagged templates that escape for you, round money without losing a cent, read a regular expression out loud, survive the Date API, and hand formatting over to Intl instead of hand rolling it.
this, Prototypes and Classes
The four rules that decide what this is, how to force it with call, apply and bind, the prototype chain every object secretly walks, what new really does, and how classes are a readable spelling of all of it. Ends with the composition patterns that let you stop reaching for inheritance.
Errors, Debugging and Testing
The skills that separate code that works on your machine from code you would put in front of users: throwing and catching deliberately, designing your own error types, validating everything that crosses a boundary, driving the debugger instead of sprinkling logs, and writing tests (including the test runner itself).
Asynchronous JavaScript
One thread, thousands of things waiting. Build the model that makes async JavaScript predictable: the event loop and its two queues, callbacks and why they lost, promises, async/await, the concurrency patterns real apps need, cancellation, async iteration, and the bug list every reviewer checks first.
Modules and Tooling
How a program made of many files becomes one running application: what export and import really do, why a module evaluates once, how dynamic import splits a bundle, what CommonJS does differently, and what each tool in a modern project is actually for.
The Browser Platform
Everything the language does not give you and the browser does: a live document tree to query and rewrite, an event system with three phases, self-validating forms, client-side storage, HTTP through fetch, observers instead of polling, canvas at sixty frames a second, and workers for a real second thread.
Advanced Language Features
The layer libraries are built from: symbols, iterators and generators, all thirteen Proxy traps, weak collections, deterministic cleanup with using, functional composition, design patterns, measured performance, the classic leaks, the usual security holes, and ES2020 to ES2026.
Data Structures and Algorithms in JavaScript
The part of computer science that survives contact with real JavaScript: how growth curves behave, why array shift is the most expensive line in most slow apps, how stacks, queues, hash maps, trees and graphs are built out of the objects you already know, and the classic interview problems, solved and measured.
Build Something Real
Seven labs, one habit: decide the architecture before you type. A reducer-driven todo app, a dashboard that survives a dead endpoint, a particle system on delta time, a physics playground behind a swappable adapter, a reactive store built from Proxy traps, a working test runner, and a search box that wins the race.
Where Next
The closing module turns knowledge into a working habit: how to read a repository you did not write, what TypeScript adds and what it costs, what frameworks actually solve and which of your skills transfer, how the same language behaves on a server, and a 90-day plan with weekly milestones you can tick off.