JavaScript Deep Dive

A guided, ground-up JavaScript course for developers who want to actually understand the language — not just copy-paste their way through it.

Twenty-two chapters, each built around one idea you can hold in your head at a time. Work through them in order and you'll go from "what is a value?" to writing your own tiny interpreter, a platform game, and a small full-stack app — in roughly the time it takes to watch two seasons of a TV show.

22chapters

14.0 hrstotal, self-paced

5guided projects

Your progress

Your progress bar above updates as you check off chapters, and it's saved only in this browser (localStorage) — no sign-up, no account, nothing sent anywhere. Finish every chapter and a certificate of completion unlocks automatically.

How this course is organized

• Concept chapters teach one topic end-to-end, with runnable code you're meant to retype, not just read.
• Project chapters (there are five, spread evenly through the course) are longer, guided builds that force you to combine everything you've learned so far into one working program.
• Every chapter ends with a "Mark this chapter complete" button. Click it once you've actually worked through the examples — the honor system is the whole system here.
• Chapters are short enough to fit into a lunch break. If you do one a day, you'll finish in under a month; two a day and you're done in under two weeks.

A note on sources

Adapted, not copied

The topic list, chapter order, and overall teaching progression of this course are inspired by the table of contents of Eloquent JavaScript, 4th edition, written by Marijn Haverbeke (the print/PDF edition is published by No Starch Press; the online edition is released under a Creative Commons license).

Every explanation, code sample, exercise, and diagram on this site, however, has been independently written and paraphrased from scratch for JavaScript360.org. We use different example scenarios, different variable and project names, and our own original diagrams — this course is not a reproduction, transcription, or derivative copy of the book's text or illustrations. If you want the original book — which is excellent, and free to read — go get it straight from the source at eloquentjavascript.net.

Full syllabus

Click any chapter to jump straight in. The checkmark fills in once you mark a chapter complete.

1. 0Welcome: Why Learn to Program in JavaScript~15 minWhat programming actually is, why JavaScript became the language of the web, and how this course is organized so you always know what’s next.
2. 1Values, Types & Operators~35 minThe raw material of every program: numbers, strings and booleans, how JavaScript compares and converts them, and where its quirks come from.
3. 2Program Structure~40 minExpressions vs. statements, bindings, and the control-flow building blocks — if, while, for and switch — that every program is made of.
4. 3Functions~45 minDeclaring and calling functions, scope and closures, recursion, and how to grow a messy script into small, reusable pieces.
5. 4Data Structures: Objects & Arrays~50 minModeling real information with objects and arrays, mutability, array methods, destructuring, and reading/writing JSON.
6. 5Higher-Order Functions~45 minTreating functions as values so you can abstract away repetition — map, filter, reduce and the art of composing small functions.
7. 6The Secret Life of Objects~50 minPrototypes, classes, encapsulation, getters/setters, and how JavaScript’s object system differs from classical OOP languages.
8. 7Project: A Delivery RobotProject~40 minA guided build: simulate a robot delivering parcels across a small town graph, and compare a naive route planner with a smarter one.
9. 8Bugs & Errors~35 minStrict mode, type mistakes, debugging strategy, and how to use exceptions and try/catch/finally to fail on purpose, safely.
10. 9Regular Expressions~45 minPattern matching for strings: character classes, groups, greediness, and using regexes for validation and text extraction.
11. 10Modules~30 minWhy large programs need to be split into files, how ES modules import and export bindings, and a look at CommonJS and bundlers.
12. 11Asynchronous Programming~50 minCallbacks, promises, async/await and the event loop — how JavaScript juggles slow operations without blocking everything else.
13. 12Project: A Tiny Programming LanguageProject~45 minWrite a miniature interpreter — a parser that turns text into a syntax tree and an evaluator that runs it — to see how languages work under the hood.
14. 13JavaScript and the Browser~25 minHow the web platform fits together: networks, HTML, the script sandbox, and why the browser is such a hostile execution environment.
15. 14The Document Object Model~40 minWalking and editing a page as a tree of nodes: finding elements, creating them, and controlling layout and style from code.
16. 15Handling Events~35 minListening for clicks, keys and other browser events, understanding propagation, and building small interactive widgets.
17. 16Project: A Platform GameProject~40 minModel a small side-scrolling level as data, run a game loop, and handle collisions — the core architecture behind most 2D games.
18. 17Drawing on Canvas~35 minPixel-level graphics with the Canvas API: shapes, paths, transforms and simple animation loops.
19. 18HTTP and Forms~30 minTalking to servers with fetch, understanding HTTP methods and status codes, and reading data out of HTML forms.
20. 19Project: A Pixel Art EditorProject~35 minCombine the DOM, canvas and state management ideas from earlier chapters into a small, interactive drawing application.
21. 20Node.js~40 minJavaScript outside the browser: the module and file systems, streams, and building a minimal HTTP server from scratch.
22. 21Project: A Skill-Sharing PlatformProject~35 minDesign a full client/server app — a small community board where people post and browse talks — tying the whole course together.

---

Chapter 0 · Welcome: Why Learn to Program in JavaScript

Estimated time: ~15 minutes · Chapter type: Orientation

What you'll get out of this chapter

• A working mental model of what "programming" actually is
• Why JavaScript — a language originally hacked together in ten days in 1995 — ended up running everywhere
• What this course assumes you already know, and what it doesn't

Programming, stripped down

A computer is relentlessly literal. It has no opinions, no common sense, and no ability to infer what you meant. Programming is the discipline of describing a process — a sequence of small, unambiguous steps — precisely enough that a machine with zero judgment can carry it out correctly, every single time, at a speed no human could match.

That's both the appeal and the frustration of the craft. The appeal: once you've described a process correctly, the computer will execute it flawlessly, forever, for free. The frustration: "correctly" is a very high bar, and the gap between "the code I wrote" and "the code that does what I meant" is where almost all of software engineering actually happens.

This course treats programming as a skill you build the same way you'd build any other: by doing small, concrete things repeatedly, with immediate feedback, until the patterns become automatic. That's why almost every chapter has runnable code — reading about a for loop teaches you very little; typing one out, breaking it, and fixing it teaches you a lot.

Why JavaScript, specifically

JavaScript has an unusual origin story. It was designed in 1995, in about ten days, to make static web pages slightly interactive — think form validation and image rollovers. It was never meant to be a serious, general-purpose programming language, which explains a lot of its early reputation for being a bit of a mess.

Three things changed that:

1. It's the only language browsers run natively. Every website that does anything beyond displaying static text runs JavaScript. That gave it a captive audience of billions of devices before it was even a "good" language.
2. The language kept improving. Since 2015, JavaScript has received a yearly update (the "ECMAScript" standard) adding real language features — proper classes, modules, promises, optional chaining, and more. Modern JavaScript is a genuinely capable, expressive language, not the toy it started as.
3. It escaped the browser. With Node.js (Chapter 20), the same language now runs servers, command-line tools, desktop apps, and even embedded devices. Learning JavaScript once now pays off across the entire stack.

None of this makes JavaScript perfect — you'll meet plenty of its rough edges in Chapter 1 — but it does make it one of the most useful languages you can learn, because you'll bump into it constantly no matter what kind of software you end up building.

What this course assumes

• You've written some code before, in any language, and you know roughly what a variable, a function, and a loop are. This is not a "what is a computer" course.
• You have Node.js installed (or are comfortable running JavaScript in a browser console) so you can actually type out the examples. Chapter 20 covers Node in depth, but you don't need to understand it yet — just have node on your PATH, or open your browser's DevTools console.
• You're willing to type the code instead of just reading it. This is the single biggest predictor of whether a course like this actually sticks.

Key takeaways

• Programming means describing a process precisely enough for a machine with no judgment to execute it correctly.
• JavaScript is worth learning deeply because of where it runs (everywhere) as much as what it is — and modern JavaScript is a much better language than its reputation suggests.
• This course rewards typing, not skimming. Keep an editor open the whole time.

Ready? Chapter 1 starts with the smallest possible building block: a single value.

 

Up nextCh. 1 — Values, Types & Operators~35 min