typescript

TypeScript type system, deep

From structural typing to type-level programming — generics, conditional and mapped types, and typing real systems.

10 units·41 lessons·~10 h

Start track →

00

Start from zero

What types buy you, and the two worlds: values and types.

01 Why types, deeply 12 min 02 Type space vs value space 13 min

01

Foundations

TypeScript types are structural and mostly inferred.

01 Structural typing: shape is the only thing the checker compares 13 min 02 Inference basics: how the checker fills in the types you didn't write 13 min 03 any, unknown, never: the top, the bottom, and the escape hatch 13 min 04 Literal types: single values as types, and the as const that keeps them 13 min

02

Everyday types

Unions plus narrowing model 'one of these, figure out which'.

01 Unions and intersections 13 min 02 Narrowing and control-flow analysis 14 min 03 User-defined type guards 14 min 04 Discriminated unions 14 min 05 keyof and indexed access types 14 min

03

Generics

Generics are functions over types — with constraints and inference.

01 Generic functions 14 min 02 Generic constraints 14 min 03 Defaults and inference 15 min 04 Generic classes 15 min 05 Variance intuition 16 min

04

The type system, deep

Conditional, mapped and template-literal types make types programmable.

01 Conditional types: a type-level ternary keyed on assignability 15 min 02 The infer keyword: pattern-match a type and capture a piece of it 16 min 03 Mapped types: iterate a type's keys to build a new one 16 min 04 Key remapping via as: rename and filter keys in a mapped type 16 min 05 Template literal types: compute, expand, and parse string types 17 min

05

Type-level programming

Recursion and distribution let you compute at the type level — within limits.

01 Recursion in types 16 min 02 Distributive conditionals 16 min 03 Utility types from scratch 18 min 04 Type-level arithmetic 18 min 05 Limits and type performance 18 min

06

Functions & this

Overloads, this-typing, assertion functions and satisfies.

01 Function overloads 14 min 02 Typing this 14 min 03 Assertion functions 14 min 04 The satisfies operator 14 min

07

Config, modules & build

tsconfig strictness and module resolution decide what compiles.

01 tsconfig strictness: what `strict` actually flips, and the flags it leaves out 14 min 02 module & moduleResolution: how an import string becomes a file 15 min 03 .d.ts files: ambient declarations, augmentation, and the public type surface 15 min 04 Project references: tsc --build, composite, and the incremental build graph 14 min 05 Type-checking vs transpilation: why your bundler doesn't catch type errors 14 min

08

Types in the real world

Type the boundaries: APIs, validation, end-to-end with tRPC.

01 Typing APIs: a fetch type is a promise, not a proof 15 min 02 zod: one schema, the static type and the runtime guard 15 min 03 tRPC: end-to-end types with no codegen, and what that costs 15 min 04 Library generics: APIs that infer beautifully (and the ones that don't) 15 min 05 Common pitfalls: traps that compile clean and bite later 15 min

09

Putting it together

Build a fully-typed feature end to end.

01 Capstone: ship one feature, typed end-to-end 18 min

Build with this track

Guided projects that exercise what you learn here.

Hot-Path Profiler Lab

Take a deliberately slow piece of JavaScript and turn it into a controlled experiment. You'll build a micro-benchmark harness you actually trust, profile the hot path until you can name what the engine is doing, and apply engine-aware fixes — monomorphism, killing megamorphic call sites, cutting allocations — proving each win with numbers instead of vibes. This is the whole discipline of performance work in miniature: measure, form a hypothesis about the engine, change one thing, measure again.

JSON parser from scratch

Write a spec-correct recursive-descent parser for JSON — tokenizer, value dispatcher, escape handler, number decoder — and watch every edge case in RFC 8259 become a concrete code path.

Type-Safe API SDK

Build the client other engineers will actually trust: a typed SDK over a real HTTP API where the compiler — not a runtime crash in production — catches the wrong field, the missing variant, the response that lied about its shape. You model the domain with discriminated unions and generics, validate every response at the boundary, and let inference carry exact types all the way to the call site, with zero `any` left to paper over the gaps.

System Design Foundations

The building blocks of large systems and the interview framework — scaling, availability, data distribution, caching, async, and reasoning about tradeoffs under load.