Command Palette

Search for a command to run...

Hectal
Phase 17Advanced18 of 18 in TypeScript

Interviews and Capstone

Interview answers backed by the compiler, live type challenges, a code-review checklist, and a fully typed task tracker built step by step.

This last phase ties the whole course together. First you practise the questions interviewers really ask about TypeScript, with answers you can check against the real compiler instead of memorising. Then you solve classic type challenges the slow way: the naive attempt, the error it gives, and the fix.

Then you learn to review TypeScript code: finding the any that leaks, the as that lies, the missing case, and the type that is too clever. You finish by building one complete typed app, a task tracker, from branded IDs to exhaustive rendering.

Every claim in an answer is backed by a live example. Predict the Types panel first, then check. If you can predict it, you understand it.

0/5 · 0%
5 topics ~3 h 18 code blocks & diagrams
Start with the first topic
1
17.1

Interview Questions: Fundamentals

The questions every TypeScript interview starts with (type vs interface, any vs unknown vs never, structural typing, enums vs unions, narrowing, satisfies), each answered completely and proved with a live example.

30 min 3 code practice

2
17.2

Interview Questions: Advanced Types

The harder questions: generics and inference, conditional and mapped types, the utility types built by hand, and variance. Every answer is backed by an example the compiler checks.

29 min 3 code practice

3
17.3

Live Type Challenges

Solve eight classic type challenges (Pick, Readonly, TupleToUnion, Last, Includes, Awaited, DeepReadonly, Chainable) the way you would in an interview: write the test first, try the naive answer, read the error, fix it.

32 min 4 code practice

4
17.4

Reviewing TypeScript Code

How to read a pull request like a TypeScript expert: spot the any that leaks, the as that lies, the switch that forgot a case and the type that is too clever, using a short checklist and code that really fails at runtime.

30 min 3 code practice

5
17.5

Capstone: A Fully Typed App

Build one typed task tracker step by step: branded IDs, a discriminated-union task state, a typed event bus, validated storage, a typed fetch client and exhaustive rendering, then run the whole app in one file.

38 min 5 code practice

Practise this phase

Hands-on exercises: write the code, see your page live, and press Check to have it tested automatically.

1

Challenge: MyPick and MyReadonly

Write the generic types MyPick<T, K> and MyReadonly<T> so the two Expect lines in the starter compile. MyPick<Todo, 'title'> must be { title: string }, and MyReadonly<Todo> must equal the built-in Readonly<Todo>.

Intermediate
2

Challenge: TupleToUnion and Last

Write TupleToUnion<T> (the union of a tuple's element types) and Last<T> (the type of its last element, or never for an empty tuple).

Intermediate
3

Challenge: Includes and MyAwaited

Write Includes<T, U>: true if the tuple T has an element that is exactly U, else false. Includes<[boolean], true> must be false (the element is boolean, not true).

Advanced
4

Review: Fix the any Leak

This function compiles, but it is dangerous: JSON.parse returns any, so parseConfig promises a Config it never checked. The program below prints ok for a config whose port is the text "8080".

Intermediate
5

Review: Make Every Case Count

The Shape type has three kinds. area ends with assertNever(shape), so the compiler reports that one kind is missing a case. Add the missing case to area.

Intermediate
6

Capstone: A Typed Store with Branded IDs

Build a small typed state store for a shopping cart. Three pieces: the action type, a reducer, and a generic Store<S, A> class.

Advanced