Skip to main content

The Tricky Parts of JavaScript

The Tricky Parts of JavaScript is a one-hour Pro course from Zack Wilson (PortEXE) covering how scope and hoisting behave, the three ways to write a function, and promises through async/await. It skips closures, this, and coercion despite the title, but earns an hour of your time if you already write JavaScript and still get surprised by it.

Reviewed inside the course with a Pro account, September 2026.

Quick answer​

The Tricky Parts of JavaScript is an intermediate, Pro-tier course: 58 minutes across 18 scrims on scope and hoisting, function styles, and promises through async/await, with no project. The first six scrims, the whole scope and hoisting block, are free previews; the rest need Pro. It skips closures, this, and coercion entirely, so pair it with Advanced JavaScript if you want that trio covered.

Is it worth your time?​

Yes, for a specific reader: someone who can build small things in JavaScript but still gets surprised by the language. Zack says so himself in the intro: "This course is for junior to mid level JavaScript developers who are looking to level up. JavaScript developers who feel as though they've hit a plateau." The course delivers exactly that for three topics, and it does it in less time than most YouTube playlists on any one of them.

The format is what makes it work. Nearly every scrim is Zack pasting in a five-line example, asking you what it will log, running it, and explaining the result. The four challenges push the same idea further: you pause, predict the output (or write the conversion), then watch the answer. For scope and hoisting, which are about the interpreter's rules rather than about building anything, that is the right way to teach.

Two caveats. The course was published in 2020 and the examples show it (one promise example uses jQuery-style $.ajax, and the relief he expresses about promises assumes you remember callback nesting). And the title promises more than the hour holds. Read the module list below before you buy expecting closures.

What you'll learn​

Scrimba presents the course as one flat list of scrims with no modules. The three groups below are mine, split where the topic changes; the intro sits with scope and the outro with promises.

Course curriculum

3 modules · 18 lessons

  1. Scope and hoisting (intro through Scope Challenge)17 min6 lessons
  2. Functions: declarations, expressions, IIFEs, arrows19 min6 lessons
  3. Promises, fetch, Promise.all, async/await (plus outro)22 min6 lessons

I counted 18 video scrims totalling 58 minutes 11 seconds, plus a certificate item and Scrimba's generic "How to Utilize Your Certificate" scrim; Scrimba's own figure is 20 lessons and 59 minutes, which counts those two extra items.

Inside the course, module by module​

1. Scope and hoisting (17 min, 6 scrims)​

Title slide of Scrimba's The Tricky Parts of JavaScript course, white text on a peach background with two lilac blobs
Six scrims on var, let, const and hoisting, ending in a challenge that mixes every rule from the block.Title card from scrimba.com.

The intro is 78 seconds of Zack introducing himself (a YouTube channel, a website) and setting expectations: JavaScript specifically, not "object oriented programming, functional programming, web APIs." What Is Scope? defines scope as "the area in which a variable is visible". It then runs three examples in under two minutes: a var inside a function that throws a ReferenceError outside it, a let read before its line (also a ReferenceError), and the same code with var (prints undefined). That last contrast is the hook for the whole block.

Hoisting is the best scrim in the course. The rule comes first, "variable declarations are figuratively hoisted to the top of its scope," and then he proves that let is hoisted too, which most explanations skip. He writes let char = 'a', an if (true) block that logs char, and a second let char = 'b' inside the block after the log. It throws.

As Zack puts it in lesson 3, "This is how we know that let is being hoisted here. Because if it wasn't, if we got rid of this, this would be logging a." He names the temporal dead zone and, sensibly, tells you not to worry about it beyond debugging. The scrim ends with function declarations being hoisted with their bodies, so square(4) works before function square is written.

The Tricky Parts of JavaScript, Hoisting lesson: the console shows a ReferenceError instead of the expected value.
At 1:35 of Hoisting, the inner let is declared after the console.log, yet the log throws instead of printing the outer 'a'.Screenshot of scrimba.com, taken by scrimbaguide.tech.

Global Scope covers top-level variables, overriding them locally, and setting properties on window from inside a function. Block Scope shows that let and const are trapped inside curly braces and var is not, then flips an if (true) to if (false) to show var x is still hoisted (as undefined) even when the block never runs.

The Scope Challenge is the payoff. Zack pastes 32 lines with six console.log calls and says "Don't run the code. I want you to figure out what each of the console dot logs is going to do." Every rule from the previous four scrims is in there. There is a var hoisted = true at the bottom of the file, a var assigned inside an if that never runs, a let at global scope written from inside a function, window.str, and a var ten that stays locked inside its function. Getting all six right without running it means you understood the block.

The Tricky Parts of JavaScript, Scope Challenge lesson: the console prints six answers after running the code.
Just after Zack runs the Scope Challenge file at 1:00, line 32, var hoisted = true, is why the first log prints nothing.Screenshot of scrimba.com, taken by scrimbaguide.tech.

2. Functions (19 min, 6 scrims)​

Function Declarations is short: the function keyword syntax, a squareNum(9) that logs 81, and a reminder that a declaration can be called before the line that defines it. Function Expressions is where the ideas start: a function assigned to a const, then a timedFunction that accepts another function and measures how long a 100,000-iteration loop takes. Zack cuts the named loop out and passes an anonymous function inline to show why expressions exist. He finishes by converting a declaration into an expression and getting a ReferenceError, because expressions "are hoisted without their definition in the same way that standard variable bindings are."

IIFE's (immediately invoked function expressions) is the longest scrim at five minutes and the one most likely to be new to a self-taught reader. Two reasons to use them: encapsulation, so an add function inside one script cannot collide with an add in another. The second is what he calls function factories, where a recursive Fibonacci is wrapped and invoked with 10 to produce tenthFib, then generalised into fibFactory(n). He is candid that "this one is a little bit more of an advanced concept, and you may not run into this very often, if ever."

Arrow Functions walks through the syntax reductions one at a time: drop function, add the arrow, drop the braces and return for a one-liner, drop the parentheses for a single argument. He shows where you cannot shorten (two arguments, more than one line) and ends with the one real difference: "Arrow functions do not have this, arguments, super, or new dot target keyword bindings." That is the only time this appears in the course, and it is a warning, not a lesson.

The Functions Challenge asks you to rewrite the fib declaration as a function expression and as an arrow function, then Part 2 asks you to turn the expression into an IIFE that assigns the tenth Fibonacci number (55). Both are quick, and both are the kind of thing you should be able to do with your eyes closed after this block.

3. Promises and async/await (22 min, 6 scrims)​

What Are Promises? opens with a definition ("a class that aims to simplify asynchronous programming") and a waitMs function that wraps setTimeout in new Promise((resolve, reject) => ...). Zack admits up front that the example "is not a super practical example," runs it, waits the full five seconds on camera, and then walks through a callApi example that resolves or rejects on an HTTP result. That second example uses $.ajax, and he does not run it; it dates the course more than anything else in it.

Fetch is the practical version: fetch a todo from JSONPlaceholder, .then(response => response.json()), .then the result. Then he breaks the URL on purpose to show .catch printing "TypeError: Failed to fetch." Promise.all is the most memorable scrim in the block. Three promises go into an array: two fetches and a hand-made promise that resolves when you click a button in the preview. Nothing logs until all three are done, and Zack has to run it twice because the requests were still in flight the first time. The result arrives as an array "in the order in which you write it, not in the order in which they are completed."

The Tricky Parts of JavaScript, Promise.all lesson: a Click Me button in the preview and an array in the console.
Promise.all at 3:55. Two fetches and one click-driven promise in a single array; the console shows the three results in array order after the button in the preview pane was pressed.Screenshot of scrimba.com, taken by scrimbaguide.tech.

Async/Await takes the fetch example from two scrims earlier and rewrites it with await. He hits the "cannot use keyword await outside of an async function" error first and fixes it with an async IIFE, which ties the functions block back in. The Promises Challenge then hands you two promises that resolve to "Hello" and "World" and asks for "Hello World." Zack shows three solutions: nested .then, Promise.all with array indexes, and an async arrow IIFE with two awaits, and says which he prefers (the second).

The Tricky Parts of JavaScript, Promises Challenge lesson: the code editor with an async await one-liner and its console output.
Promises Challenge at 3:00, the third of three solutions. One line of async/await replaces the nested .then version from a minute earlier; the console shows Hello World.Screenshot of scrimba.com, taken by scrimbaguide.tech.

The Outro is 77 seconds. Zack lists what to learn next, "iterators, generators, closures, recursion," which confirms that closures are homework, not content, and points to his Twitter and YouTube.

What a lesson feels like​

A scrim here is one to five minutes, and the pattern barely changes: an empty index.js, Zack pastes a short example, asks what it will print, runs it, explains. There is no project to keep in your head between scrims and no CSS or HTML to speak of; index.html exists but only the Promise.all scrim uses it (for the button). You can pause at any point and edit the code yourself, which is the main advantage over watching the same material on YouTube.

The challenges are pause-and-predict rather than pause-and-build. Zack says "pause this cast, look at the code, think carefully about it," and then gives the answer. Nothing checks your work: you compare your answer with his. I did not see any of the "Challenge with Instant Feedback" markers that newer Scrimba courses show in their table of contents.

The delivery is relaxed and slightly unpolished. He pastes the wrong snippet once in the IIFE scrim ("I pasted in the wrong part"), mixes up "synchronous" and "asynchronous" once, and says "um" more than a scripted course would. I did not mind; it sounds like a developer explaining something at a desk.

Every scrim has captions, a timestamped transcript in the settings menu, and subtitles in ten languages.

Free or Pro: exactly what is gated​

Six scrims carry the SAMPLE badge and play without a subscription: the intro, the four scope scrims (What Is Scope?, Hoisting, Global Scope, Block Scope) and the Scope Challenge. That is the entire scope and hoisting block, 17 minutes, free. It is also the strongest part of the course, so you can judge the teaching style before paying.

Pro unlocks the other 12 scrims (functions and promises, 41 minutes) and the certificate of completion. This is a standalone course, not part of any career path. Scrimba's pricing page lists basic Discord access as free and Pro-only channels as Pro, so the community itself is not gated. There are no Solo Projects in this course; nothing else inside it is locked. See current plans (opens in a new tab) for what Pro costs in your region.

How long it takes​

The runtime is 58 minutes of video, listed as 59 on Scrimba because its count includes the certificate items (see the note under the curriculum above). If you only watch, that is an evening. If you do what the course asks, which is to pause at every "what do you think this logs?" and actually decide before he runs it, and to write the two function conversions and the promise challenge yourself, plan for two to three hours. The Scope Challenge alone is worth ten minutes of thinking before you press play. Spread it over two sittings, one for scope and functions and one for promises, and you will keep more of it.

Who it's for, and who should skip it​

Take it if you have finished Learn JavaScript or its equivalent, can write functions and loops, and have hit the wall where the language does something you cannot explain. It is also a fast refresher before an interview that might ask "what does this log?" style questions about var and hoisting, and a gentle first pass at promises for someone who has been copying fetch snippets without understanding them.

Skip it if you are a complete beginner (the intro says so; nothing is explained from zero), or if you already know why let throws in the temporal dead zone and how Promise.all orders its results. Skip it too if you came for closures, this, prototypes, or coercion; none of those are in the hour, whatever the title implies. Advanced JavaScript is the fuller course for that ground.

Try the free scope lessons on Scrimba (opens in a new tab)

Prerequisites​

Comfortable basic JavaScript: variables, functions, if blocks, arrays, and console.log. Zack assumes you have seen fetch at least once and know what an HTTP request is, but not that you understand promises. Nothing needs installing; every example runs in Scrimba's browser editor with a console pane.

Where it fits​

Scrimba does not list it under any career path; it is a standalone course. In practice it sits between a first JavaScript course and anything that leans on asynchronous code. The promises block is direct preparation for the data fetching in Learn React and for Learn Node.js, where nearly everything returns a promise. The scope block pairs well with JavaScript Interview Challenges, which drills the same "predict the output" skill under time pressure.

Strengths and limits​

What it does well: it proves each rule with a runnable example instead of stating it, it shows the errors (ReferenceError, "cannot use keyword await outside of an async function", "Failed to fetch") on screen rather than describing them, the Scope Challenge is a real test of understanding, and the scope block is free.

Where it is limited: the title oversells it (no closures, this, or coercion), the promise intro leans on a 2020-era $.ajax example, there is no project and nothing checks your challenge answers, and at 18 scrims it is a supplement you will finish in an evening rather than a course you grow with.

Related Guides

Next step

Frontend Developer Path

Docs
Last updated on