TypeScript Crash Course

Lesson 1 • Writing and Compiling Your First Program

Write a minimal TypeScript file, compile it, and inspect the JavaScript output. Connects theory to practice by showing the full authoring cycle.

Lesson 2 • Installing and Configuring the Toolchain

Install Node.js, the TypeScript compiler, and a code editor with TypeScript support. Produces a ready-to-use local development environment.

Lesson 3 • The tsconfig.json File

Understand every major compiler option in tsconfig.json and how they affect output. Enables precise project-level control over type checking and emit behaviour.

Lesson 1 • Type Inference and the any Type

Understand when TypeScript infers types automatically and when explicit annotations are required. Explains why overusing any undermines the type system.

Lesson 2 • Arrays, Tuples, and Enums

Type fixed and variable-length collections and define named constant sets with enums. Covers the most common structured data patterns in everyday TypeScript code.

Lesson 3 • Object Types and Type Aliases

Define object shapes inline and with reusable type aliases. Teaches how to model domain data clearly and avoid repetition across a codebase.

Lesson 4 • Primitive Types

Cover string, number, boolean, null, undefined, symbol, and bigint with their behavioural differences. Provides the atomic building blocks for all typed expressions.

Lesson 1 • Access Control and Encapsulation

Apply private fields, getters, setters, and readonly to protect internal state. Reinforces encapsulation as a design discipline within TypeScript classes.

Lesson 2 • Defining and Using Interfaces

Declare interfaces to describe object shapes and function signatures. Establishes the primary contract mechanism used throughout object-oriented TypeScript.

Lesson 3 • Implementing Interfaces with Classes

Use the implements keyword to bind classes to interface contracts. Shows how to design loosely coupled systems that are easy to test and swap.

Lesson 4 • Classes in TypeScript

Define classes with typed properties, constructors, and methods. Builds on interface knowledge to show how classes implement and enforce contracts.

Lesson 1 • Generic Constraints

Restrict type parameters with extends constraints to access specific properties safely. Prevents runtime errors by narrowing what types a generic can accept.

Lesson 2 • Generic Interfaces and Classes

Apply type parameters to interfaces and classes to create reusable data structures. Extends interface and class knowledge into parameterised, multi-type designs.

Lesson 3 • Introduction to Generics

Understand the problem generics solve and write the first generic function. Connects to prior function typing knowledge by showing how type parameters generalise signatures.

Lesson 1 • Conditional Types

Write types that resolve differently based on a condition using T extends U ? X : Y. Unlocks expressive type-level logic for library and framework authors.

Lesson 2 • Union and Intersection Types

Combine types with | and & to express values that can be one of several shapes. Provides the foundation for discriminated unions and type narrowing.

Lesson 3 • Mapped Types

Transform existing types by iterating over their keys with mapped type syntax. Enables systematic property transformations without manual duplication.

Lesson 4 • Template Literal Types

Construct string types dynamically using template literal syntax at the type level. Enables precise typing of string patterns such as event names and CSS properties.

Lesson 1 • Path Aliases and Project References

Configure path aliases in tsconfig.json and split large codebases with project references. Improves build performance and import readability in monorepo setups.

Lesson 2 • Namespaces and Module Augmentation

Use namespaces for logical grouping and augment existing module types. Covers legacy patterns and the modern technique of extending third-party type definitions.

Lesson 3 • ES Modules in TypeScript

Use import and export syntax to split code across files with full type checking. Connects compiler options to module resolution behaviour in real projects.

Lesson 1 • Async Iterators and Generators

Use AsyncIterator<T> and async generator functions to model streaming data. Extends iterator knowledge to asynchronous data sources such as streams and paginated APIs.

Lesson 2 • Typing Promises

Annotate Promise<T> return types and understand how the generic parameter flows through then chains. Builds on generics knowledge to type async data correctly.

Lesson 3 • Typing Callbacks and Event Emitters

Define typed callback signatures and strongly type event emitter patterns. Covers legacy async patterns still common in Node.js and browser APIs.

Lesson 1 • Unit Testing with Typed Test Frameworks

Write unit tests in TypeScript using a typed test runner and assert types at runtime. Ensures test code benefits from the same type safety as production code.

Lesson 2 • Linting TypeScript with ESLint

Configure ESLint with TypeScript-aware rules to enforce code style and catch type-related issues. Complements the compiler by surfacing problems the type checker does not flag.

Lesson 3 • Build Pipelines and Bundlers

Integrate TypeScript compilation into bundler workflows using tools like esbuild or Webpack. Covers source maps, watch mode, and optimised production builds.

Lesson 4 • Debugging TypeScript Applications

Use source maps and editor debuggers to step through TypeScript source at runtime. Closes the loop between authoring and diagnosing issues in running applications.