TypeScript

Why TypeScript exists, how it compiles away, and the vocabulary for describing values, functions and objects.

1. 1Why TypeScript8 minWhat TypeScript actually is — a type checker that compiles away to plain JavaScript — and the class of bug it catches before your code ever runs.
2. 2Setting Up a TypeScript Project7 minInstall TypeScript, generate a tsconfig.json, and understand what the compiler actually does with target, module and outDir before you write a line of typed code.
3. 3Basic Types and Inference9 minThe primitive types, how TypeScript infers a type from a value without being told, and why annotating everything is usually the wrong instinct.
4. 4Functions in TypeScript10 minTyping parameters and return values, optional and default parameters, rest parameters, overloads, and the type of a function itself.
5. 5Object Types and Interfaces9 minDescribing the shape of an object with an inline type or an interface, optional and readonly properties, and index signatures for dynamic keys.
6. 6Type Aliases vs Interfaces8 minWhat a type alias can do that an interface can't (and the reverse), and a practical rule for choosing between them.

Combining types with unions and intersections, narrowing them safely, and the fixed shapes: tuples, enums, unknown and any.

1. 7Union and Intersection Types9 minCombine types with | for "one of these" and & for "all of these", and use literal types to describe a fixed set of exact values.
2. 8Narrowing11 minTurn a union into one specific type inside a branch using typeof, instanceof, in, truthiness, and discriminated unions — the core skill of working with TypeScript day to day.
3. 9Arrays, Tuples, and Enums10 minreadonly arrays, fixed-length tuples with a type per position, and enums versus the union-of-literals alternative most style guides now prefer.
4. 10unknown, any, and Type Guards10 minWhy any silently turns off type checking and unknown doesn't, and how to write your own reusable type guard functions with the is keyword.

Writing one function, interface or class that works across many types, and the utility types built from the same idea.

1. 11Generics Fundamentals11 minWrite one function that works across many types without losing type safety, using type parameters, constraints with extends, and default type arguments.
2. 12Generic Interfaces and Classes9 minApply generics beyond standalone functions — to interfaces, type aliases, and classes — and read the generic types you already use every day, like Array<T> and Promise<T>.
3. 13Utility Types, Part 1: Partial, Required, Readonly, Pick, Omit10 minFive built-in generic types that transform an existing type instead of redeclaring it by hand — the most commonly reached-for tool in real TypeScript code.
4. 14Utility Types, Part 2: Record, Exclude, Extract, and the Function Ones10 minRecord for typed dictionaries, Exclude and Extract for filtering unions, and pulling a function's types back out with ReturnType, Parameters, and Awaited.

Access modifiers, inheritance, and the abstract classes that let one interface cover many concrete implementations.

1. 15Classes and Access Modifiers10 minpublic, private, and protected members, readonly fields, parameter properties, and what TypeScript's private actually protects compared to JavaScript's own
2. 16Abstract Classes and Polymorphism9 minimplements versus extends, abstract classes that can't be instantiated directly, and how TypeScript checks that a class actually satisfies the interfaces it claims to.

Type-level programming: types that branch on a condition, map over another type's keys, and build new string types.

1. 17Conditional Types10 minTypes that branch on a condition with extends ? :, how they distribute automatically over unions, and extracting a nested type with infer.
2. 18Mapped Types10 minBuild a new object type by looping over an existing type's keys with in keyof, add or strip modifiers with +/-, and rename keys with key remapping.
3. 19Template Literal Types9 minBuild new string types out of unions the same way template literals build strings out of values, and combine them with mapped types to generate related keys.

Modules, third-party types, tsconfig strictness, satisfies, async code, and migrating an existing JavaScript codebase.

1. 20Modules and Declaration Files9 minExporting and importing types alongside values, the import type syntax, and how a .d.ts file describes the shape of code without providing any implementation.
2. 21Working with Third-Party Types8 minDefinitelyTyped and the @types scope, reading a library's type errors, and augmenting a type you don't own through declaration merging.
3. 22Configuring tsconfig.json and Strictness11 minWhat the strict flag actually turns on, the individual checks that make it up, and the other tsconfig options that affect real projects most: target, module, and skipLibCheck.
4. 23as const and satisfies9 minLock a value down to its most literal type with as const, and check a value against a type without widening or losing its inferred literal shape using satisfies.
5. 24Typing Asynchronous Code10 minHow Promise<T> and async functions are typed, why a caught error is unknown, and typing an API response honestly instead of trusting fetch's built-in any.
6. 25Migrating JavaScript to TypeScript10 minA realistic, incremental path for adding TypeScript to an existing codebase: allowJs, converting files gradually, JSDoc as a stepping stone, and the mistake that quietly undoes it.