JavaScript, from zero to developer

How long it takes

71 hours of material. That is the sum of the lesson estimates, not a marketing number . Pick a pace you can keep.

• 1 h/day

  ~10 weeks

• 2 h/day

  ~5 weeks

• 3 h/day

  ~3 weeks

• Full time, 6 h/day

  ~12 days

The 12 modules

1. 1. Programs, values, and types0/8 lessons · 6h · 10 exercises

   Run a program, print a value, and name every kind of value JavaScript has.

   1. What a program actually is40 min · 1 exercise
   2. Running a program and reading its output40 min · 1 exercise
   3. Numbers and arithmetic50 min · 2 exercises
   4. Text values, a first look45 min · 1 exercise
   5. True, false, and comparing values45 min · 1 exercise
   6. Naming values: let and const45 min · 1 exercise
   7. undefined, null, and naming every type45 min · 1 exercise
   8. Coercion, and the two kinds of equals50 min · 2 exercises
2. 2. Making decisions0/6 lessons · 5h · 7 exercises

   Make a program take a different path depending on its input.

   Builds on Programs, values, and types, you can start here anyway, but that is the order it was written in.

   1. if, else, and blocks50 min · 2 exercises
   2. Truthiness and the falsy values45 min · 1 exercise
   3. and, or, and the nullish fallback55 min · 1 exercise
   4. switch, and when to avoid it45 min · 1 exercise
   5. The conditional operator45 min · 1 exercise
   6. Project: building a decision table60 min · 1 exercise
3. 3. Functions: naming and reusing behaviour0/7 lessons · 6h · 8 exercises

   Package behaviour behind a name someone else can call.

   Builds on Making decisions, you can start here anyway, but that is the order it was written in.

   1. Declaring and calling your first function45 min · 1 exercise
   2. Parameters, arguments and defaults50 min · 1 exercise
   3. Return values and early return55 min · 1 exercise
   4. Function expressions and arrow functions50 min · 1 exercise
   5. Scope and shadowing55 min · 1 exercise
   6. Closures: functions that remember55 min · 2 exercises
   7. Pure functions and side effects50 min · 1 exercise
4. 4. Structured data: arrays and objects0/7 lessons · 7h · 14 exercises

   Hold many related values and reach into them safely.

   Builds on Functions: naming and reusing behaviour, you can start here anyway, but that is the order it was written in.

   1. Arrays: many values under one name55 min · 2 exercises
   2. Changing a list: adding, removing, copying60 min · 2 exercises
   3. Objects: values with names instead of positions60 min · 2 exercises
   4. Shapes inside shapes60 min · 2 exercises
   5. Unpacking and rebuilding: destructuring and spread60 min · 2 exercises
   6. References: when two names mean one thing60 min · 2 exercises
   7. Reaching in safely: optional chaining and defaults65 min · 2 exercises
5. 5. Iteration and array transformation0/7 lessons · 7h · 12 exercises

   Turn one collection into another without writing the same loop twice.

   Builds on Structured data: arrays and objects, you can start here anyway, but that is the order it was written in.

   1. Repeating work with for and while55 min · 2 exercises
   2. for...of and for...in: items and keys55 min · 2 exercises
   3. forEach, and when a plain loop is clearer55 min · 1 exercise
   4. map: one array in, a new array out60 min · 2 exercises
   5. filter, find, some and every: asking questions of a collection65 min · 2 exercises
   6. reduce: many values into one70 min · 2 exercises
   7. Project: chaining transformations into a pipeline60 min · 1 exercise
6. 6. Strings and text processing0/6 lessons · 5h · 9 exercises

   Take apart, clean up and rebuild text you did not write.

   Builds on Iteration and array transformation, you can start here anyway, but that is the order it was written in.

   1. Strings cannot be changed, only rebuilt45 min · 1 exercise
   2. Building text out of values45 min · 1 exercise
   3. Finding things and cutting pieces out55 min · 2 exercises
   4. Splitting, joining and cleaning up55 min · 2 exercises
   5. Comparing text people actually typed50 min · 1 exercise
   6. Regular expressions: a first pass50 min · 2 exercises
7. 7. Errors, validation, and defensive code0/6 lessons · 5h · 9 exercises

   Decide what your code does when the input is wrong.

   Builds on Functions: naming and reusing behaviour and Strings and text processing, you can start here anyway, but that is the order it was written in.

   1. What an error actually is45 min · 1 exercise
   2. Throwing, and the objects you throw50 min · 1 exercise
   3. try, catch, finally55 min · 2 exercises
   4. Validating input at the boundary55 min · 1 exercise
   5. Returning outcomes instead of throwing50 min · 2 exercises
   6. Failing loudly, not silently45 min · 2 exercises
8. 8. Asynchronous JavaScript0/6 lessons · 6h · 2 exercises

   Explain why some results arrive later, and write code that waits correctly.

   Builds on Functions: naming and reusing behaviour and Errors, validation, and defensive code, you can start here anyway, but that is the order it was written in.

   1. Callbacks, and why they exist65 min · 2 exercises
   2. The event loop and the job queue60 min

      Taught but not graded: the sandbox has no promise job draining, timers yet, and the lesson says so where it matters.

   3. Promises: what they actually model65 min

      Taught but not graded: the sandbox has no promise job draining yet, and the lesson says so where it matters.

   4. async and await65 min

      Taught but not graded: the sandbox has no promise job draining, top level await yet, and the lesson says so where it matters.

   5. Sequential versus parallel waiting50 min

      Taught but not graded: the sandbox has no promise job draining, timers yet, and the lesson says so where it matters.

   6. Async mistakes that bite55 min

      Taught but not graded: the sandbox has no promise job draining, timers yet, and the lesson says so where it matters.

9. 9. Modelling real data without a browser0/6 lessons · 6h · 7 exercises

   Choose a shape for real data and change it without breaking it.

   Builds on Structured data: arrays and objects and Iteration and array transformation and Strings and text processing, you can start here anyway, but that is the order it was written in.

   1. Choosing a shape for your data60 min · 1 exercise
   2. JSON: turning data into text and back60 min · 1 exercise
   3. Lookup tables: finding one thing quickly55 min · 1 exercise
   4. Map and Set: when a plain object is the wrong tool60 min · 1 exercise
   5. Changing data without breaking it60 min · 1 exercise
   6. Project: modelling an invoice65 min · 2 exercises
10. 10. Modules, packages, and the toolchain0/6 lessons · 5h · 2 exercises

    Read a real project's layout and understand what the tools do.

    Builds on Functions: naming and reusing behaviour and Modelling real data without a browser, you can start here anyway, but that is the order it was written in.

    1. What a module is55 min · 1 exercise
    2. Named and default exports55 min · 1 exercise
    3. Packages and package.json50 min

       Taught but not graded: the sandbox has no modules and host apis yet, and the lesson says so where it matters.

    4. Versions and lockfiles45 min

       Taught but not graded: the sandbox has no modules and host apis yet, and the lesson says so where it matters.

    5. Bundlers, transpilers, and runtimes50 min

       Taught but not graded: the sandbox has no modules and host apis yet, and the lesson says so where it matters.

    6. Project layout and scripts45 min

       Taught but not graded: the sandbox has no modules and host apis yet, and the lesson says so where it matters.

11. 11. Testing and debugging0/6 lessons · 5h · 8 exercises

    Prove your code works and find out why when it does not.

    Builds on Errors, validation, and defensive code and Modules, packages, and the toolchain, you can start here anyway, but that is the order it was written in.

    1. What a test actually is55 min · 2 exercises
    2. Arrange, act, assert50 min · 1 exercise
    3. Edge cases and boundaries55 min · 2 exercises
    4. Test doubles without a framework50 min · 1 exercise
    5. Debugging by bisection50 min · 2 exercises
    6. How this maps to Vitest40 min

       Taught but not graded: the sandbox has no modules and host apis yet, and the lesson says so where it matters.

12. 12. Capstone: build a small library end to end0/6 lessons · 8h · 6 exercises

    Build, test and review a small library end to end against a brief.

    Builds on Iteration and array transformation and Strings and text processing and Errors, validation, and defensive code and Modelling real data without a browser and Modules, packages, and the toolchain and Testing and debugging, you can start here anyway, but that is the order it was written in.

    1. The brief, and what 'done' means60 min
    2. Choosing the shape of a session90 min · 1 exercise
    3. The core functions, written test first100 min · 2 exercises
    4. Error paths: deciding what happens when the entry is wrong85 min · 2 exercises
    5. Refactoring: changing the shape without changing the answer80 min · 1 exercise
    6. Reviewing your own library, and knowing when it is done65 min