JavaScript Course: Fundamentals to TypeScript

This JavaScript course teaches the language before any framework, because the most common reason developers get stuck is that they learned React without learning JavaScript — and then cannot tell which problem belongs to which.

Stage 1: the language, including its rough edges

JavaScript has genuinely surprising behaviour. Teaching it well means explaining the actual rules rather than offering rules of thumb that break later.

So coercion and the equality rules are derived rather than avoided. Closures are taught as a tool — the mechanism behind module privacy, memoisation and event handlers — rather than as an interview curiosity. The behaviour of this is derived from how calls work, so students can reason about an unfamiliar case instead of recalling four memorised ones.

Prototypes come before class, because class syntax is sugar over the prototype chain, and a student who knows the chain can debug inheritance problems that a student who only knows class cannot.

Stage 2: asynchrony, properly understood

This is the stage that separates confident JavaScript developers from anxious ones.

Students learn the event loop mechanically: the call stack, the task queue, the microtask queue, and the ordering consequences. Given two snippets that look equivalent, they can say which logs first and why — which is the foundation for every async bug they will meet.

From there: callbacks and their failure modes, promises and correct error handling, async/await, concurrent work with Promise.all and its siblings, and cancellation with AbortController. Error handling is treated as a first-class topic, because an unhandled rejection in production is a silent failure.

ES2026, stated accurately

ES2026 was approved on 30 June 2026 and contains exactly seven features. The course teaches all of them, and two matter more than their size suggests.

Uint8Array gains native toBase64(), toHex(), fromBase64() and fromHex(), removing a dependency most projects previously installed. And JSON.parse's reviver now receives the raw source text while JSON.rawJSON() fixes the stringify side — together letting a BigInt make a complete round trip through JSON, which was previously impossible without a library.

The rest: Array.fromAsync, Math.sumPrecise, Map.prototype.getOrInsert, iterator helpers, Set methods and RegExp.escape.

What is not in ES2026 is taught just as clearly. Temporal and explicit resource management — the using and await using syntax — are both widely written about as though they had landed. They did not. Both reached stage 4 after the cut-off and are expected in 2027, with Atomics.pause and joint iteration. A student who knows the difference between standard and forthcoming writes code that actually runs.

Stage 3: the platform and the tooling

The browser is covered directly: the DOM, events and delegation, forms and validation, fetch, and storage — all without a framework, so students can see what frameworks are doing for them later.

The developer tools are taught as an instrument: breakpoints, the network panel, the performance profiler. Most developers use perhaps a tenth of what the tools offer, and the rest is where the hard bugs are found.

Then modules, npm and lockfiles, a bundler, a linter and formatter, and a test runner — plus Node for scripts and a small HTTP server, so the language is understood outside the browser too.

Stage 4: TypeScript

TypeScript is introduced as the answer to a problem students have by now felt: a JavaScript codebase past a certain size becomes hard to change safely.

Coverage runs from basic and composite types through interfaces, unions and narrowing to generics and strict mode. The emphasis is the practical skill of adding types incrementally to existing JavaScript, file by file — which is how real adoption happens, rather than a rewrite.

The capstone is deliberately framework-free

The final project is a single-page application in TypeScript with no framework: modules, async data loading, rendered state from data, tests and a build.

That constraint is the point. A student who has managed state and rendering by hand understands what React is solving when they meet it, and makes better decisions about when a framework is warranted. Our web development course then builds on exactly this foundation.

Who this suits

Students from Class 9 upward and undergraduates, including complete beginners. JavaScript is a reasonable first language because the feedback loop is immediate — a browser is the entire environment, with nothing to install.

Small online groups of up to eight, so code is reviewed line by line rather than skimmed.