JavaScript
The complete path through the language that runs the web: from why JavaScript exists and your first line of code, through closures, the event loop, and the DOM, down to how engines parse, compile, optimize, and garbage-collect your code, and how the specification defines it all. Each lesson pairs a short explanation with code you can step through.
Why JavaScript?
What JavaScript is, what you can build with it, and why every browser runs it.
// What you’ll learn
- The language of the web
- Front end, back end, mobile & desktop
- What makes it approachable
- JavaScript is not Java
Your progress
View detailed stats- day streak
- 0
- days this week
- 0
- stages done
- 0/12
Recent activity
View allLessons you open and finish, and your quiz scores, show up here.
Next up for you
Quick actions
Recommended for you Based on your progress
- Coming up: Language fundamentalsStage 2 starts with Variables: let, const & var. Declare, assign, and name the values your program keeps.
- Practice in the playgroundWrite and run your own JavaScript, with examples to start from and the console beside it.
- How these lessons are madeThe sources, structure, checks, and Tuto behind every lesson on the path.
The learning path
343 of 343 available12 stages, in order. Each one builds on the last, from absolute beginner to engine and specification internals. Jump to a stage, or search for any topic.
- STAGE 1 · BEGINNERGetting started3 modules · 14 lessons
- STAGE 2 · BEGINNERLanguage fundamentals4 modules · 24 lessons
- STAGE 3 · BEGINNER TO INTERMEDIATEWorking with data5 modules · 28 lessons
- STAGE 4 · INTERMEDIATEHow JavaScript works4 modules · 19 lessons
- STAGE 5 · INTERMEDIATEObjects, prototypes & classes4 modules · 19 lessons
- STAGE 6 · INTERMEDIATEAsynchronous JavaScript3 modules · 14 lessons
- STAGE 7 · INTERMEDIATEJavaScript in the browser7 modules · 43 lessons
- STAGE 8 · ADVANCEDAdvanced language features6 modules · 34 lessons
- STAGE 9 · ADVANCEDProfessional JavaScript6 modules · 35 lessons
- STAGE 10 · EXPERTInside the engine8 modules · 54 lessons
- STAGE 11 · EXPERTThe runtime & the platform5 modules · 31 lessons
- STAGE 12 · EXPERTThe specification & the language4 modules · 28 lessons
343 lessons in 12 stages and 59 modules.
Stage 1 Beginner
Getting started
Why JavaScript exists, where it runs, and how to write, run, and debug your first programs.
3 modules · 14 lessons
- 4 lessons · 46 min
Module 1: Welcome to JavaScript
What the language is, why it matters, and how it became the language of the web.
- 5 lessons · 1 h 2 min
Module 2: Your first programs
Set up your tools, run code, and learn the structure every program shares.
- 5 lessons · 1 h 2 min
Module 3: Debugging & code quality
Find bugs quickly and write code other people can read.
Stage 2 Beginner
Language fundamentals
Values, operators, decisions, loops, and functions: the building blocks of every program.
4 modules · 24 lessons
- 10 lessons · 2 h 7 min
Module 4: Variables & values
Store values, name them well, and meet the eight types JavaScript has.
- 4.1Variables: let, const & var (has a video)12 min
- 4.2Data types (has a video)12 min
- 4.3Numbers & math (has a video)13 min
- 4.4Strings (has a video)14 min
- 4.5Booleans & truthiness (has a video)14 min
- 4.6undefined (has a video)14 min
- 4.7null13 min
- 4.8Booleans, null & undefined11 min
- 4.9BigInt12 min
- 4.10Type conversion12 min
- 5 lessons · 1 h 2 min
Module 5: Operators & expressions
Compute, compare, and combine values.
- 4 lessons · 50 min
Module 6: Control flow
Make decisions and repeat work.
- 5 lessons · 1 h 3 min
Module 7: Functions
Package code into reusable pieces that take input and return output.
Stage 3 Beginner to intermediate
Working with data
Objects, arrays, strings, collections, and dates: model real data and transform it.
5 modules · 28 lessons
- 7 lessons · 1 h 22 min
Module 8: Objects
Group related data and behavior under one name.
- 6 lessons · 1 h 14 min
Module 9: Arrays
Ordered lists and the methods that search, transform, and sort them.
- 4 lessons · 48 min
Module 10: Strings & text
Search, slice, format, and truly understand text.
- 7 lessons · 1 h 23 min
Module 11: Destructuring & collections
Unpack values, and pick the right structure for your data.
- 4 lessons · 52 min
Module 12: Dates, numbers & Intl
Work with time, format numbers, and speak the user's language.
Stage 4 Intermediate
How JavaScript works
Execution contexts, scope, closures, this, and coercion: the rules behind the code you already write.
4 modules · 19 lessons
- 5 lessons · 1 h
Module 13: Execution & the call stack
What happens when JavaScript runs your file, one execution context at a time.
- 5 lessons · 1 h 1 min
Module 14: Scope & closures
Which code can see which variables, and functions that remember.
- 5 lessons · 1 h 2 min
Module 15: this & function methods
How this is decided, and how call, apply, and bind take control.
- 4 lessons · 47 min
Module 16: Types & coercion in depth
The spec's conversion rules, so == and + never surprise you again.
Stage 5 Intermediate
Objects, prototypes & classes
Inheritance, classes, property internals, and error handling: build robust object models.
4 modules · 19 lessons
- 5 lessons · 59 min
Module 17: Prototypes & inheritance
How objects inherit behavior from other objects.
- 7 lessons · 1 h 26 min
Module 18: Classes
The class syntax, inheritance, and encapsulation.
- 4 lessons · 49 min
Module 19: Property internals
Descriptors, accessors, and the rules that control every property.
- 3 lessons · 40 min
Module 20: Error handling
Expect failure, handle it, and report it clearly.
Stage 6 Intermediate
Asynchronous JavaScript
Timers, the event loop, promises, and async/await: code that waits without blocking.
3 modules · 14 lessons
- 4 lessons · 55 min
Module 21: The event loop
How single-threaded JavaScript handles work that finishes later.
- 6 lessons · 1 h 29 min
Module 22: Callbacks & promises
From callback hell to values that arrive later.
- 4 lessons · 54 min
Module 23: async & await
Asynchronous code that reads from top to bottom.
Stage 7 Intermediate
JavaScript in the browser
The DOM, events, forms, network requests, storage, and browser APIs: build real interfaces.
7 modules · 43 lessons
- 9 lessons · 2 h 5 min
Module 24: The DOM
Read and change the page from JavaScript.
- 8 lessons · 1 h 44 min
Module 25: Events
Respond to clicks, keys, and everything users do.
- 4 lessons · 58 min
Module 26: Forms
Read, validate, and submit user input.
- 7 lessons · 1 h 46 min
Module 27: Network requests
Talk to servers with fetch and real-time connections.
- 4 lessons · 57 min
Module 28: Storing data in the browser
Keep data between visits.
- 5 lessons · 1 h 10 min
Module 29: Browser APIs
Observers, animation, drawing, files, and devices.
- 6 lessons · 1 h 22 min
Module 30: Workers, routing & components
Background threads, offline apps, client-side routing, frames, and Web Components.
Stage 8 Advanced
Advanced language features
Iteration protocols, modules, metaprogramming, functional techniques, regular expressions, and binary data.
6 modules · 34 lessons
- 5 lessons · 1 h 11 min
Module 31: Iterators & generators
The protocol behind for…of, and functions that pause.
- 5 lessons · 1 h 5 min
Module 32: Modules
Split code into files with import and export.
- 5 lessons · 1 h 11 min
Module 33: Metaprogramming
Code that inspects and changes how other code behaves.
- 8 lessons · 1 h 55 min
Module 34: Functional programming
Build programs from small, predictable functions.
- 6 lessons · 1 h 24 min
Module 35: Regular expressions
Search and transform text with patterns.
- 5 lessons · 1 h 19 min
Module 36: Binary data & memory
Bytes, buffers, and how memory is managed.
Stage 9 Advanced
Professional JavaScript
Tooling, testing, patterns, security, and performance: ship JavaScript that holds up in production.
6 modules · 35 lessons
- 5 lessons · 1 h 22 min
Module 37: Tooling & the ecosystem
The tools between your code and your users.
- 5 lessons · 1 h 24 min
Module 38: Testing & debugging
Prove your code works, and find out fast when it doesn't.
- 6 lessons · 1 h 39 min
Module 39: Design patterns & architecture
Proven shapes for organizing JavaScript code.
- 7 lessons · 2 h 4 min
Module 40: Build it from scratch
Rebuild language features and classic utilities to prove you understand them.
- 6 lessons · 1 h 47 min
Module 41: Security
Write JavaScript that attackers can't turn against your users.
- 6 lessons · 1 h 40 min
Module 42: Performance
Measure first, then make it fast.
Stage 10 Expert
Inside the engine
How engines like V8, SpiderMonkey, and JavaScriptCore parse, compile, optimize, lay out, and garbage-collect your code.
8 modules · 54 lessons
- 7 lessons · 1 h 56 min
Module 43: Engine architecture
The pieces of a JavaScript engine, and the path from source text to running code.
- 8 lessons · 2 h 15 min
Module 44: JIT compilation & optimization
How engines watch your code run, then compile the hot parts to fast machine code.
- 12 lessons · 3 h 26 min
Module 45: Values & objects inside the engine
How engines lay out numbers, strings, objects, arrays, and functions in memory.
- 45.1Tagged values, Smis & heap numbers17 min
- 45.2Booleans inside the engine17 min
- 45.3undefined inside the engine17 min
- 45.4null inside the engine17 min
- 45.5Strings inside the engine17 min
- 45.6BigInt inside the engine17 min
- 45.7Symbols inside the engine17 min
- 45.8Hidden classes & object shapes18 min
- 45.9Fast arrays & elements kinds18 min
- 45.10Functions & closures inside the engine17 min
- 45.11Prototypes inside the engine17 min
- 45.12The heap & pointer compression17 min
- 7 lessons · 1 h 58 min
Module 46: The call stack in depth
What a stack frame really holds, how calls, returns, and exceptions work, and how stack traces are built.
- 8 lessons · 2 h 23 min
Module 47: Garbage collection in depth
The algorithms that free memory automatically, and the trade-offs behind them.
- 47.1Why garbage collection?17 min
- 47.2Reference counting & cycles16 min
- 47.3Mark-sweep & mark-compact16 min
- 47.4Generational collection & the Scavenger18 min
- 47.5Write barriers & remembered sets18 min
- 47.6Incremental, concurrent & parallel GC18 min
- 47.7Weak references & ephemerons18 min
- 47.8Garbage collection across engines & the DOM22 min
- 4 lessons · 1 h 15 min
Module 48: Memory in practice
Measure, profile, and fix memory problems in large apps and servers.
- 4 lessons · 1 h 11 min
Module 49: Asynchrony inside the engine
How promises, await, and the microtask queue are implemented.
- 4 lessons · 1 h 12 min
Module 50: Performance at the engine level
Write code that stays on the fast path, and prove it with engine tools.
Stage 11 Expert
The runtime & the platform
How browsers and Node.js host the engine: event loops, rendering, module loading, threads, embedding, and security.
5 modules · 31 lessons
- 7 lessons · 2 h 6 min
Module 51: The event loop in depth
The real processing model behind tasks, microtasks, and rendering.
- 8 lessons · 2 h 24 min
Module 52: How browsers run JavaScript
Processes, threads, and the pipeline from HTML bytes to running scripts and pixels.
- 52.1Browser architecture18 min
- 52.2What happens when you navigate18 min
- 52.3From HTML to running script18 min
- 52.4The rendering pipeline18 min
- 52.5How input reaches your event handlers18 min
- 52.6Bindings: how DOM objects exist in JavaScript18 min
- 52.7Realms, globals & WindowProxy18 min
- 52.8The browser security model18 min
- 6 lessons · 1 h 48 min
Module 53: Modules under the hood
How module graphs are loaded, linked, and evaluated.
- 5 lessons · 1 h 34 min
Module 54: Threads, agents & realms
Shared memory, atomics, and truly parallel JavaScript.
- 5 lessons · 1 h 30 min
Module 55: Engines & runtimes beyond the browser
Isolates, embedders, and the runtimes built on top of engines.
Stage 12 Expert
The specification & the language
Understand JavaScript the way engine authors and TC39 do: the spec's model, its legacy, its tooling, and where it's heading.
4 modules · 28 lessons
- 12 lessons · 3 h 46 min
Module 56: Reading the specification
Understand JavaScript the way engine authors do.
- 56.1How to read ECMAScript19 min
- 56.2Spec types: Completion, Property Descriptor & more19 min
- 56.3The Reference type & this18 min
- 56.4Environment Records: how scope is specified18 min
- 56.5Execution contexts & jobs in the spec19 min
- 56.6Function calls: [[Call]] & [[Construct]]19 min
- 56.7Internal methods & exotic objects22 min
- 56.8A tour of the abstract operations19 min
- 56.9Lexical grammar & ASI18 min
- 56.10Syntax, early errors & static semantics19 min
- 56.11Evaluation order18 min
- 56.12test262 & conformance18 min
- 5 lessons · 1 h 28 min
Module 57: Legacy JavaScript & web compatibility
Sloppy mode, Annex B, and the deprecated features the web can't remove.
- 5 lessons · 1 h 29 min
Module 58: The evolving language
How new features are made, and what's coming next.
- 6 lessons · 2 h 14 min
Module 59: Tools that understand JavaScript
Parse, analyze, and transform JavaScript yourself, the way compilers and linters do.