What you'll learn:
- Answer the JavaScript questions an interview actually digs into, and know why the answer is the answer.
- Take the event loop apart frame by frame: the call stack, tasks and microtasks, nextTick versus setImmediate, and where the browser differs from Node.
- Work fluently across callbacks, promises, async/await, generators and async iterators, and know which one a problem is asking for.
- Explain this, closures, the scope chain, hoisting and the temporal dead zone without hand-waving.
- Predict what a piece of code prints before you run it, on the exercises that run through the whole course.
- Use the prototype chain and class syntax knowing exactly what one is doing on top of the other.
- Reach for the modern language properly: destructuring, spread and rest, iterator helpers, Map and Set, Symbols, BigInt and template tags.
- Talk about the platform around the language: ES modules versus CommonJS, memory and garbage collection, where TypeScript fits, and what landed in ES2026.
There is a developer on every team who always knows why. When the bug makes no sense, when the async code fires in the wrong order, when nobody can explain what the this keyword is actually bound to... that is who everyone goes to. This course is about becoming that developer.
In around twelve hours you will go from writing JavaScript to genuinely understanding it: the difference between a good developer and the senior one in the room. You will dramatically improve your chances of getting past a technical interview, landing the job you actually want, and being paid what that developer gets paid.
If you are like me, you learnt JavaScript by muddling along: seeing what worked, picking up a thing or two every day. It gets you a long way (until it doesn't). Without the deeper fundamentals you hit head-scratching bugs, you find framework and library source hard to read, and in an interview you can hear yourself describing what happens without being able to say why.
Every lecture is an interview question, because the moment you properly learn something is when there is an interview in front of you. There is always an obvious right answer, and a good interviewer goes one step past it. That step is where this course lives.
What are you going to learn?
Types & Equality — the types JavaScript really has, and what it takes for two values to be equal.
Scopes & Variables — hoisting, the scope chain, closures, and the temporal dead zone.
Destructuring & Modern Arrays — destructuring, spread and rest, the array methods that landed after map and filter, and iterator helpers.
This — a whole section on the this keyword. A deep understanding of it is core to becoming a senior JavaScript developer.
Object Orientation — the history of OO in JavaScript, from the prototype chain through the constructor pattern to the class syntax. You need the earlier patterns to truly understand the current one.
Async, properly — five sections on it: what asynchronous really means, callbacks and the mess they make, promises and every combinator, async/await, and generators with async iterators.
The Event Loop — taken apart frame by frame, in Node and in the browser, until the ordering questions stop being guesswork.
Networking & Events — CORS and the same-origin policy, fetch, event capturing and bubbling, and event delegation.
Modern Platform — ES modules versus CommonJS, how memory is managed, where TypeScript fits, and what landed in ES2026.
Exercises run the whole way through. You predict what the code prints, then we run it and find out together.
Why an interview format?
I find it is only when I am facing an upcoming interview that I get into gear and really make sure I have a deep understanding of what I claim to know. I might know the best practice for solving a problem... but do I know why?
JavaScript interviews are designed to dig deeper, to see whether you are mimicking what you have read or whether you actually understand it. Also, it is FUN. What is more satisfying than learning something and then passing the test?
Ten years of updates
I first built this course in 2016 and I have been updating it ever since.. it has just been rebuilt for 2026. That history is the point. JavaScript is backwards compatible, so it never throws anything away, it only adds layers. Learn it in those layers and the strange behaviour stops being trivia and starts being obvious: a class stops being magic the moment you have seen the prototypes underneath it.
