TypeScript

How TypeScript automatically figures out types so you don't have to.

The difference between TypeScript's two 'catch-all' types.

Understanding the difference between functions that return nothing and functions that never return.

Overriding TypeScript's inferred types when you know better than the compiler.

TypeScript's core philosophy: Duck Typing.

How TypeScript infers general types from specific values, and how you restrict them back down.

Combining multiple types into one, representing an OR relationship.

Combining multiple types into one, representing an AND relationship.

The most robust way to handle complex state and union types in TypeScript.

Ensuring all possible cases of a union are handled at compile time.

Techniques for narrowing down broad types into specific types.

Writing your own functions to help TypeScript narrow complex types.

Narrowing types by throwing errors instead of returning booleans.

How the TypeScript compiler reads your code like a JavaScript engine.

Understanding the differences between the two ways to define object shapes.

Building complex interfaces from simpler ones using the extends keyword.

How TypeScript combines multiple declarations with the same name into a single definition.

Defining types for objects where you don't know the property names ahead of time.

Writing reusable, type-safe code that works over a variety of types.

Restricting the types that can be passed into a Generic parameter.

How TypeScript automatically figures out Generic types from context.

Applying generics to object-oriented classes and data structures.

Built-in generic types for common type transformations.

Iterating over keys to create new object types dynamically.

How to write Partial, Pick, and Omit from scratch.

The core operators for querying and extracting types.

Writing IF/ELSE logic at the type level.

String interpolation at the type level.

Types that reference themselves to model infinitely nested data.

Using the TypeScript type system as a Turing-complete programming language.

Typing parameters, return values, and function signatures.

Providing multiple distinct signatures for a single function.

Typing the context of the 'this' keyword inside functions.

How TypeScript enhances standard JavaScript classes with types.

Controlling the visibility of class properties and methods.

Base classes that cannot be instantiated directly, but require subclasses to implement specific methods.

Understanding the difference between inheriting from classes and fulfilling interfaces.

How TypeScript handles isolating and sharing code between files.

Optimizing compilation by explicitly importing types separately from values.

Providing type information for untyped JavaScript libraries.

Patching existing modules to add new types or properties.

Configuring the TypeScript compiler.

The most important flag in TypeScript.

How TypeScript figures out where your imports come from.

Scaling TypeScript in massive Monorepos.

The most important concept for using TypeScript in a backend environment.

Keeping the frontend and backend in perfect sync.

Protecting your Node.js application from malicious or malformed data.

Handling the 'unknown' nature of exceptions in TypeScript.

The industry standard for syncing compile-time types with runtime validation.

A common interview challenge: Making nested properties optional.

A common interview challenge: Freezing nested objects at compile time.

The hardest TypeScript interview question: Converting A | B into A & B.

How to approach advanced TypeScript challenges in interviews.

High-level architectural and theoretical questions for senior roles.

Tricky code snippets testing your deep understanding of TS quirks.

How to handle live-coding interviews using TypeScript.