JavaScript & TypeScript
The language of the web, done properly: modern JavaScript from the ground up, the type safety of TypeScript, asynchronous programming, and the tooling that underpins every frontend and Node backend.
JavaScript, done properly
Many developers learn just enough JavaScript to get by and never build a real model of the language, which causes endless confusion later. This program teaches it properly: values and types, functions, closures, and scope, objects and prototypes, and the module system and toolchain. Understanding how JavaScript actually works is what turns a frustrating language into a productive one.
That solid model matters because JavaScript is unavoidable. It runs every browser and, through Node.js, a huge share of backends. Learning it deliberately rather than by accident means you can work confidently across the frontend and backend of the modern web, which is exactly what the programs after this one assume.
That solid foundation is what the whole modern web assumes, and building it deliberately, rather than absorbing JavaScript by accident, is what lets you work confidently across frontend and backend instead of copying patterns you do not understand.
Asynchronous programming
Asynchronous code is where JavaScript trips up the most developers, so the program treats it as a central topic. You learn the event loop, the progression from callbacks to promises to async/await, how to fetch and work with APIs, and how to handle errors in asynchronous code. These are the concepts behind every real web application, and understanding them clearly removes a whole category of bugs.
The program teaches the concurrency patterns that JavaScript's single-threaded model relies on, so you understand not just the syntax of async/await but what is actually happening underneath. This understanding is what lets you reason about performance and correctness in real applications rather than copying patterns you do not understand.
Mastering async is the single biggest step in becoming a competent web developer, because so many real bugs live in asynchronous code, and understanding the event loop is what turns those bugs from mysteries into obvious mistakes.
TypeScript and tooling
TypeScript has become the default for serious JavaScript, and the program covers it thoroughly: why types help, the TypeScript model, basic and advanced types, generics, and type narrowing. You learn to configure and adopt TypeScript in a real project, which is how most developers actually encounter it, incrementally, on an existing codebase.
The program finishes with the tooling that every web project needs: package managers and bundlers, linting and formatting, testing, and Node.js fundamentals. A typed application capstone pulls it together. This tooling fluency is what makes you productive on any real frontend or Node project, and it is the natural bridge into the Full Stack program.
TypeScript has become the default for a reason, and the tooling fluency this program adds is what makes you productive on any real project, which is exactly why it is positioned as the bridge into full-stack work.
See the method, not just the topic
A representative worked example from the program, so you can see the level of concreteness the curriculum works at.
// A typed, reusable API fetcher. The generic <T> ties the
// return type to what the caller expects.
async function getJSON<T>(url: string): Promise<T> {
const res = await fetch(url);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
return res.json() as Promise<T>;
}
interface User { id: number; name: string; }
const user = await getJSON<User>("/api/user/1");
console.log(user.name.toUpperCase()); // OK: name is a string
console.log(user.nam.toUpperCase()); // compile error: typo caught
// TypeScript flags "nam" before the code ever runs. In plain
// JavaScript this would fail silently at runtime, in production.The full syllabus
Four modules of five chapters each, sequenced so the material builds cumulatively. Each chapter carries a note on what it teaches.
Module 1Modern JavaScript
- 01Values, types, and the language modelValues, types, and the JavaScript language model. A real model of the language ends years of confusion.
- 02Functions, closures, and scopeFunctions, closures, and scope. Closures are the idea behind much of JavaScript.
- 03Objects, prototypes, and classesObjects, prototypes, and classes. Prototypes explain how objects really work.
- 04Arrays and iterationArrays and iteration. Iteration is everywhere in real code.
- 05Modules and the modern toolchainModules and the modern toolchain. The toolchain is what modern JavaScript runs on.
Module 2Asynchronous JavaScript
- 06The event loopThe event loop, explained. The event loop explains why async behaves as it does.
- 07Callbacks, promises, and async/awaitCallbacks, promises, and async/await. async/await makes asynchronous code readable.
- 08Fetch and working with APIsFetching and working with APIs. Talking to APIs is most of what web code does.
- 09Error handling in async codeHandling errors in async code. Async error handling prevents silent failures.
- 10Concurrency patterns in JavaScriptConcurrency patterns in JavaScript. These patterns keep a single-threaded model responsive.
Module 3TypeScript
- 11Why types, and the TypeScript modelWhy types help, and the TypeScript model. Types catch a whole class of bugs before runtime.
- 12Basic and advanced typesBasic and advanced TypeScript types. Advanced types model real-world data precisely.
- 13GenericsGenerics for reusable, safe code. Generics give you safety without repetition.
- 14Type narrowing and guardsType narrowing and guards. Narrowing lets the compiler prove your code is safe.
- 15Configuring and adopting TypeScriptAdopting TypeScript on a real project. Most teams adopt TypeScript incrementally, as you will.
Module 4Tooling and quality
- 16Package managers and bundlersPackage managers and bundlers. Bundlers turn many files into what ships.
- 17Linting, formatting, and configLinting, formatting, and configuration. Consistent config keeps a codebase healthy.
- 18Testing JavaScript and TypeScriptTesting JavaScript and TypeScript. Tests are what let you change code with confidence.
- 19Node.js fundamentalsNode.js fundamentals. Node.js runs JavaScript on the backend.
- 20A typed application capstoneBuilding a typed application capstone. The capstone is a typed app ready for a framework.
How the program is taught
The program teaches JavaScript properly from the ground up rather than assuming you will absorb it, then layers TypeScript on top. Every concept is applied in code, and the asynchronous material in particular is taught with the event loop made visible, because that understanding is what removes a whole category of bugs.
It builds toward a typed application and the tooling a real project needs, so you finish not just knowing the language but able to set up and work in a professional JavaScript or TypeScript codebase. That practical tooling fluency is a core goal, not an afterthought.
Prerequisites and pace
The program assumes basic programming familiarity but teaches JavaScript itself from first principles, so it suits both newcomers to the language and developers who know it only superficially. The tooling-foundations program is a helpful precursor for complete beginners.
The pace moves from the language model through async to TypeScript and tooling, and the async section rewards extra attention since it is where most confusion lives. Working the examples rather than reading past them is what builds real fluency.
What makes this program different
Many developers learn just enough JavaScript to get by and carry the resulting confusion for years. This program's distinction is teaching the language properly, closures, prototypes, the event loop, so you have a real model rather than a bag of half-understood patterns.
The TypeScript depth is the other distinction. Rather than treating types as an add-on, the program teaches generics, narrowing, and adoption on real code, which is how TypeScript is actually used and what makes it genuinely valuable at scale.
What you will be able to do
- Write modern, idiomatic JavaScript
- Master asynchronous programming and the event loop
- Add type safety with TypeScript, including generics
- Set up bundlers, linters, and tests
- Build a typed application ready for a framework
Who should take it
- Developers moving into web development
- Frontend engineers wanting real TypeScript depth
- Node.js backend developers
- Anyone preparing for the Full Stack program
Common questions
A common question is whether to learn JavaScript or TypeScript, and the answer is both, in that order: TypeScript is JavaScript with types, so a real understanding of JavaScript is what makes TypeScript make sense. The program teaches them as one progression.
Another is whether this is only for frontend work. It is not: through Node.js, JavaScript and TypeScript run backends too, and the program covers Node fundamentals, so the skills apply across the full web stack, not just the browser.
Where it leads
The program opens frontend, Node backend, and full-stack roles, which are among the most abundant in software. The typed-application capstone demonstrates the practical, tooling-aware capability those roles expect.
More immediately, it is the direct preparation for the Full Stack program, so it leads naturally into building complete web applications with React and Next.js on the foundation it provides.
How it fits the journey
JavaScript and TypeScript open the web-and-applications stage and are the prerequisite for Full Stack Development. Building this foundation first means the full-stack program can focus on building applications rather than teaching the language.
For anyone heading toward web development, this is the program that makes the rest of the web track tractable, which is why it is positioned as the bridge between the core languages and the applied web programs.
What you build and keep
Build a typed application end to end: start in modern JavaScript, migrate it to TypeScript with proper types and generics, handle real asynchronous API calls, and set up the bundling, linting, and testing that a production codebase needs.
Format: Self-paced with hands-on labs; the natural bridge into Full Stack Development.
Run this program for your team
Every program can be delivered as a private, tailored cohort for your organization, aligned to your systems, policies, and career frameworks.
Scope a corporate cohortFrequently asked questions
What is the JavaScript & TypeScript program?
The language of the web, done properly: modern JavaScript from the ground up, the type safety of TypeScript, asynchronous programming, and the tooling that underpins every frontend and Node backend.
Who is this program for?
It suits developers moving into web development, along with others described on this page.
How is it delivered?
Self-paced with hands-on labs; the natural bridge into Full Stack Development.
Is there a project or capstone?
Build a typed application end to end: start in modern JavaScript, migrate it to TypeScript with proper types and generics, handle real asynchronous API calls, and set up the bundling, linting, and testing that a production codebase needs.
How does this fit the wider journey?
JavaScript and TypeScript open the web-and-applications stage and are the direct prerequisite for Full Stack Development, which builds React and Next.js frontends on the foundation this program provides.
Can my organization run this as a private cohort?
Yes. Every program can be delivered as a tailored corporate cohort. Contact us to scope it.