Learn TypeScript from zero to production-ready: environment setup & tsconfig configuration, primitive types & basic structures, union & intersection & literal types, interface & type alias, array & tuple & enum, typed functions, generics, class & modules, type guards & narrowing, mapped & conditional types, JavaScript to TypeScript migration, external library type declarations, JSX/TSX, TypeScript in Node.js, contract-driven development, testing & linting & editor support, build output & source maps, incremental builds, strict mode, up to a production-ready TypeScript project with 23 episodes in total.
Before touching TypeScript, you need to master JavaScript ES6+ as a foundation, understand the concept of types, and be familiar with npm. In this episode you'll set up Node.js, VS Code, install TypeScript, and verify your first compilation.

The first episode discusses the problems TypeScript solves: runtime bugs that should have been caught while writing code. You'll see a JavaScript vs TypeScript comparison, the benefits of a static type system for productivity, and when TypeScript is the right choice.

This episode dissects tsconfig.json as the center of compiler configuration: target, module, strict, outDir, and rootDir. You'll also learn basic tsc commands like noEmit and watch, plus supporting tooling to run TypeScript directly.

This episode introduces the alphabet of the TypeScript type system: string, number, boolean, bigint, symbol, null, and undefined. You'll also learn the special types any, unknown, void, and never, plus the difference between annotation and inference.

This episode unlocks TypeScript's expressive power: union types with the | operator for values that can take several shapes, literal types to lock in specific values, and intersection types with the & operator to combine object types.

This episode teaches how to name object shapes with interface and type alias. You'll learn optional properties, readonly, index signatures, the fundamental differences between interface and type, and when each is more appropriate.

This episode covers three ways to model collections of data: arrays with T[] and Array syntax, tuples for fixed-length value pairs, and enums for enumerations. You'll also compare enums with the more recommended literal unions.

This episode covers function typing in depth: parameter and return type annotations, optional parameters, default values, rest parameters, and function overloads. You'll also see when to write the return type explicitly.

This episode introduces generics, the most powerful tool for writing code that works across many types. You'll learn generic functions, type parameters, constraints with extends, and generic interfaces and classes with default type parameters.

This episode covers class typing in TypeScript: property declarations, parameter properties, inheritance, access modifiers, readonly, and abstract classes with implements. You'll also see when OOP is the right choice.
