JavaScript: Zero to Builder

1. Values & variables

Every program is manipulation of values, and a variable is a name a value can be referred by. This lesson builds JavaScript's value model from the ground up: the eight types, the difference between primitives and objects, what `const` and `let` really declare, how assignment copies (or does not copy) data, type coercion and the equality operators, and the habits that prevent the language's famous surprises. Values and variables are where every bug you will ever debug ultimately lives, so the time spent here pays for itself many times over.

2. Conditions & loops

Control flow is how a program decides what to do and how many times to do it. This lesson covers JavaScript's branching constructs (`if`/`else if`/`else`, the ternary, `switch`, early returns), its iteration toolkit (`for`, `for...of`, `while`, `for...in`), short-circuit and nullish operators, and the array methods that express loops declaratively. It also walks through writing a loop correctly — initialisation, condition, update — and the boundary bugs that produce infinite loops and off-by-one errors.

3. Functions & scope

A function is a named block of behaviour: parameters in, values out, and a scope that decides which names it can see. This lesson covers declaration styles, parameters and defaults, return values, lexical scope and closures, higher-order functions, pure versus impure functions, and the design rules that keep functions small enough to test — naming, single responsibility, and returning data instead of mutating distant state. Functions are where code stops being a list of instructions and starts being a program you can reason about.

4. Arrays & objects

Real data has shape: lists of things, and each thing with named parts. Arrays and objects are JavaScript's two structural primitives, and almost every program is built from them nested together. This lesson covers array mechanics and the mutation rules, object creation and access, destructuring and the spread operator, reference equality, deep versus shallow copying, JSON as the interchange format, and the method pipelines that turn arrays into results. It ends with the pattern that underlies every API you will ever consume: an array of objects, normalised once at the boundary.

1. The DOM & events

A web page becomes a program the moment JavaScript can read and change it — through the Document Object Model, the live tree of objects the browser builds from your HTML. This lesson covers how the DOM is structured and queried, how events bubble and how to listen correctly, the event object, delegation for dynamic content, forms, and the architecture that keeps a scripted page maintainable: state in one place, render from it, never patch the DOM at random. This is the lesson where your JavaScript stops logging to a console and starts being an interface.

2. Async JavaScript & APIs

Real programs wait: for the network, for a timer, for the user. JavaScript handles that with an event loop, callbacks, promises and `async`/`await` — a model where nothing blocks and every result arrives later. This lesson builds that model from the event loop up, teaches `fetch` and the HTTP contract it exposes, works through the four states every request must handle (loading, success, empty, error), and covers the resilience layer that separates a demo from a product: timeouts, retries with backoff, race conditions and cancellation.

3. Build & ship the task planner

Everything in this course now becomes one program. This lesson is the build: a task planner with add, complete, edit, filter and persistence, designed the way real applications are — data model first, then state and actions, then rendering, then storage, then the edge cases that only show up under real use. You will also plan the work (small vertical slices), debug it methodically, and finish with the checklist that turns a local file into something you can send someone. The architecture here — one state object, pure update functions, one render pass — is exactly the model React formalises in the next course.