Lies we Tell Ourselves As Developers

How can 10 lines of valid TypeScript still be full of runtime errors? Discover the surprising gaps in its type system.

#1about 2 minutes

The hidden dangers in everyday TypeScript code

A seemingly simple code snippet that passes type checks can still be riddled with runtime errors that TypeScript is supposed to prevent.

#2about 2 minutes

Why network requests returning `any` breaks type safety

The `any` type returned by default from I/O operations like `fetch` allows unsafe assignments, which can be mitigated by patching interfaces to return `unknown`.

#3about 2 minutes

Handling errors safely with the `unknown` type

Since anything can be thrown in JavaScript, catch block errors are typed as `any`, but using `unknown` and `instanceof` checks provides a safer way to handle them.

#4about 2 minutes

The disconnect between function overloads and implementation

Function overloads define a public API but do not enforce that the implementation correctly returns the specified types for each overload signature.

#5about 1 minute

Using conditional types to enforce return types

Conditional types can replace function overloads to create a more complex type signature that forces the developer to correctly handle different return paths.

#6about 3 minutes

How mutability breaks TypeScript's type tracking

TypeScript does not track type changes that occur from mutable operations like `array.push`, leading to a disconnect between the static type and the runtime value.

#7about 5 minutes

The trade-offs and lies within the solutions

Each proposed solution, from declaration merging to generics, introduces its own set of new problems and potential bugs.

#8about 3 minutes

Understanding TypeScript's core design philosophy

TypeScript intentionally prioritizes developer productivity over a provably sound type system, requiring developers to understand and manage these trade-offs.

#9about 3 minutes

The developer's role is to make conscious decisions

Software engineering is about making informed decisions and choosing the right tools and patterns for your team, rather than following dogmatic advice.

#10about 6 minutes

Q&A on Rust, `instanceof` alternatives, and `ts-reset`

The speaker answers audience questions about his favorite language (Rust), using Zod for runtime type checking instead of `instanceof`, and the trade-offs of using `ts-reset`.