Typescript on Dev & Platform Engineering Hub

Pulumi Ep 15: Multi-Language Components (MLC)

Sun, 09 Aug 2026 16:40:00 +0000

In Episode 7, we built a reusable TypeScript ComponentResource. But what if the Data Science team wants to use your component in their Python IaC? Historically, they couldn’t. Pulumi Multi-Language Components (MLC) solves this by using gRPC to project your TypeScript code across all supported languages.

Pulumi Ep 14: Policy as Code with CrossGuard

Sun, 09 Aug 2026 16:30:00 +0000

In Terraform, enforcing security rules requires external tools like OPA (Open Policy Agent) and Rego. Pulumi provides a native Policy-as-Code engine called CrossGuard. In this episode, we will write TypeScript policies that act as a strict firewall, preventing developers from provisioning insecure infrastructure.

Pulumi Ep 13: Unit Testing Infrastructure (Jest)

Sun, 09 Aug 2026 16:20:00 +0000

Testing infrastructure usually means deploying it to a sandbox, waiting 15 minutes, running a bash script to ping an IP, and tearing it down. Because Pulumi is TypeScript, we can use the industry-standard Jest testing framework to write offline, millisecond unit tests to validate our infrastructure logic before we ever touch the cloud.

Pulumi Ep 12: Authoring Dynamic Providers

Sun, 09 Aug 2026 16:10:00 +0000

What happens when you need to provision a resource in a system that doesn’t have an official Pulumi plugin? In Terraform, you must write complex Go code, compile a binary, and distribute it. In Pulumi, you can author a Dynamic Provider directly in your index.ts file using pure TypeScript.

Pulumi Ep 11: The Automation API (Embedded Pulumi)

Sun, 09 Aug 2026 16:00:00 +0000

Running pulumi up from a CLI is great for Platform Engineers, but what if you want to build a self-service Internal Developer Portal (IDP) where developers click a button on a web page to provision a database? The Pulumi Automation API allows you to embed the entire Pulumi Engine inside your own Node.js, Python, or Go applications.

TS Ep 70: Building a REST API with Effect

Sun, 09 Aug 2026 15:55:00 +0000

We assemble the ultimate functional backend. Learn how to combine Layers, Context, Schema Validation, Error Handling, and Resource Management into a massive, production-grade Express REST API using @effect/platform.

TS Ep 69: Managing Resources and Scope

Sun, 09 Aug 2026 15:50:00 +0000

Learn how to safely acquire and release resources like database connections and file streams. The Scope API replaces try/finally blocks, guaranteeing cleanup even if your application crashes.

TS Ep 68: Effect Schema Validation

Sun, 09 Aug 2026 15:45:00 +0000

TypeScript interfaces do not exist at runtime. To protect your application from malformed API payloads and corrupted database rows, learn how to use @effect/schema to parse and validate data perfectly.

Pulumi Ep 10: Using Native Providers (AWS Classic vs AWS Native)

Sun, 09 Aug 2026 15:40:00 +0000

Did you know that the @pulumi/aws package you have been using is actually built on top of Terraform? In this final intermediate episode, we explore the difference between ‘Bridged’ providers and ‘Native’ providers, and learn how @pulumi/aws-native directly communicates with the AWS Cloud Control API.

TS Ep 67: Concurrency and Fibers

Sun, 09 Aug 2026 15:40:00 +0000

Learn how Effect-TS implements Fibers (green threads) to allow millions of concurrent operations. Master Effect.all, concurrency limits, and safe interruption of background tasks.

TS Ep 66: Layers & Service Wiring

Sun, 09 Aug 2026 15:35:00 +0000

Providing single services is easy, but enterprise applications have massive dependency graphs. Learn how to use Effect Layers to wire services together, handle async initialization, and resolve graphs perfectly.

Pulumi Ep 9: Pulumi Packages and the Registry

Sun, 09 Aug 2026 15:30:00 +0000

Platform Engineering is rarely confined to a single cloud. You often need to provision AWS servers, configure GitHub repositories, and set up DataDog dashboards simultaneously. In this episode, we learn how to leverage the Pulumi Registry to install third-party Providers and orchestrate multi-cloud deployments from a single TypeScript file.

TS Ep 65: Context & Dependency Injection

Sun, 09 Aug 2026 15:30:00 +0000

Eliminate global singletons and complex IoC containers. Learn how the R parameter in Effect<A, E, R> forces you to provide dependencies before your program can run, ensuring perfect testability.

TS Ep 64: Error Handling in Effect

Sun, 09 Aug 2026 15:25:00 +0000

Effect-TS completely reimagines error handling. Learn the difference between Expected Failures and Unexpected Defects, and how to use catchTag to build resilient, self-documenting pipelines.

Pulumi Ep 8: Cross-Stack References (Micro-Stacks)

Sun, 09 Aug 2026 15:20:00 +0000

Deploying your entire infrastructure (Networking, Databases, Kubernetes, and Frontend) in a single Pulumi stack is dangerous. A tiny typo in an S3 bucket configuration could accidentally trigger the destruction of your VPC. In this episode, we learn how to architect Micro-Stacks and stitch them together using StackReference.

TS Ep 63: Creating and Running Effects

Sun, 09 Aug 2026 15:20:00 +0000

To use Effect-TS, you must know how to bridge the gap between the chaotic outside world and your pure functional pipeline. Master the constructors and execution methods of the Effect runtime.

TS Ep 62: The Effect Type Signature

Sun, 09 Aug 2026 15:15:00 +0000

The heart of Effect-TS is its three-parameter type signature. Master the A (Success), E (Error), and R (Requirement) parameters to unlock perfect architectural safety.

Pulumi Ep 7: Abstraction with ComponentResources

Sun, 09 Aug 2026 15:10:00 +0000

Terraform relies on Modules for abstraction, which are essentially isolated directories of HCL files. Pulumi takes a much more elegant approach. Because we are using a real programming language, we can abstract complex architectures into reusable TypeScript Classes called ComponentResources.

TS Ep 61: Introduction to Effect-TS

Sun, 09 Aug 2026 15:10:00 +0000

We have built the functional foundation. Now it is time to enter the ecosystem. Discover why Effect-TS is rapidly becoming the standard library for enterprise TypeScript, and run your first pure asynchronous program.

TS Ep 60: Function Composition (Pipe & Flow)

Sun, 09 Aug 2026 15:05:00 +0000

Learn how to avoid the ‘Pyramid of Doom’ and method chaining limitations by embracing functional composition. We explore how pipe and flow allow you to build complex logic from small, testable pure functions.

Pulumi Ep 6: Loops and Conditional Infrastructure

Sun, 09 Aug 2026 15:00:00 +0000

Welcome to the Intermediate Tier. The true advantage of using a general-purpose programming language for IaC is access to native control flow. In this episode, we will dynamically generate Subnets and Security Group rules using native array mapping and conditional logic based on environment flags.

TS Ep 59: Monadic Patterns (Option & Either)

Sun, 09 Aug 2026 15:00:00 +0000

Learn how to wrap missing data and expected errors in type-safe containers. We explore the Option and Either monads, providing the final foundational step before entering the Effect-TS ecosystem.

TS Ep 58: Algebraic Data Types (ADTs)

Sun, 09 Aug 2026 14:55:00 +0000

Learn how to eliminate impossible states from your application by mastering Algebraic Data Types (ADTs). We explore Sum Types, Product Types, and exhaustive pattern matching in TypeScript.

Pulumi Ep 5: Inputs, Outputs, and Promises (The Asynchronous Conundrum)

Sun, 09 Aug 2026 14:50:00 +0000

When you write standard TypeScript, data is computed immediately. But in Pulumi, when you request an EC2 instance’s IP address, the IP does not exist until AWS physically boots the server. This introduces temporal paradoxes. In this final fundamental episode, we master Inputs, Outputs, and how to safely manipulate asynchronous infrastructure data.

TS Ep 57: Immutability & Readonly Data

Sun, 09 Aug 2026 14:50:00 +0000

Functional programming requires data to be immutable. Discover how to leverage TypeScript’s structural typing, Readonly<T>, and as const to enforce deep immutability at compile time, eliminating a massive category of state-based bugs.

TS Ep 56: Functional Programming Basics & Pure Functions

Sun, 09 Aug 2026 14:45:00 +0000

Welcome to the final module! Before diving into Effect-TS, we must build a foundation in Functional Programming. Learn why pure functions eliminate whole classes of bugs, how separating descriptions from execution powers the Effect runtime, and how to refactor impure services into highly testable functional pipelines.

TS Ep 24: The Polymorphic `this` Type & Fluent APIs

Sun, 09 Aug 2026 14:40:00 +0000

An in-depth analysis of the polymorphic this type in TypeScript. Learn how returning : this preserves subclass type identities during method chaining, build type-safe Fluent Builder APIs, and use explicit this parameters for callback binding safety.

TS Ep 23: Static Members, Static Blocks, and Singletons

Sun, 09 Aug 2026 14:35:00 +0000

An in-depth analysis of static class members in TypeScript. Learn how static properties attach to constructor functions, static access control, static blocks (static {}), static inheritance, and implementing the Singleton Pattern using private constructors.

Pulumi Ep 3: Declaring Resources in TypeScript

Sun, 09 Aug 2026 14:30:00 +0000

In Terraform, you write declarative configuration blocks. In Pulumi, you instantiate Object-Oriented classes. This episode explores how to declare complex resources like an AWS VPC, Security Group, and EC2 instance using pure TypeScript, while leveraging your IDE’s IntelliSense for maximum productivity.

TS Ep 22: Abstract Classes & Template Method Pattern

Sun, 09 Aug 2026 14:30:00 +0000

An in-depth guide to Abstract Classes in TypeScript. Learn how abstract class prevents direct instantiation, enforcing method implementation contracts on subclasses while sharing concrete base logic using the Template Method design pattern.

TS Ep 21: Class Inheritance, `super()`, and the `override` Keyword

Sun, 09 Aug 2026 14:25:00 +0000

An in-depth exploration of class inheritance in TypeScript. Learn how extends establishes prototypal chain linkages, super() constructor constraints, method overriding with super.method(), and using TypeScript 4.3+ override modifier to prevent silent refactoring bugs.

TS Ep 20: Implementing Interfaces (`implements` Keyword)

Sun, 09 Aug 2026 14:20:00 +0000

An in-depth analysis of interface implementation in TypeScript. Learn how implements validates class structure, why implements does not infer method parameter types automatically, implementing multiple interfaces, and public contract enforcement.

TS Ep 19: Getters, Setters, and Asymmetric Accessors

Sun, 09 Aug 2026 14:15:00 +0000

An in-depth analysis of class accessors in TypeScript. Learn how get and set intercept reading and writing, computed properties, backing field naming patterns, and TypeScript 4.3+ Asymmetric Accessor Types.

Pulumi Ep 1: Introduction to Pulumi and Project Initialization

Sun, 09 Aug 2026 14:10:00 +0000

It is time to leave YAML behind. In this episode, we will install the Pulumi CLI, scaffold a brand new TypeScript project, and understand the anatomy of the generated files. You will learn how Pulumi securely integrates with your cloud provider credentials.

TS Ep 18: Parameter Properties — Concise Class Initializations

Sun, 09 Aug 2026 14:10:00 +0000

Learn how TypeScript parameter properties compress field declarations, constructor parameter typing, and this assignments into one line. Understand compilation behavior, inheritance interaction with super(), and common duplicate identifier gotchas.

TS Ep 17: Access Modifiers & Hard Private Fields (#)

Sun, 09 Aug 2026 14:05:00 +0000

An in-depth analysis of class encapsulation. Understand the visibility matrix of public, private, and protected modifiers, inheritance rules in subclasses, compile-time type erasure, and how ES2022 hard private fields (#) provide true runtime isolation.

TS Ep 16: Class Basics, Field Declarations, and Constructors

Sun, 09 Aug 2026 14:00:00 +0000

An in-depth guide to TypeScript classes. Learn how field declarations differ from standard ES6 JavaScript, how strictPropertyInitialization eliminates uninitialized field bugs, readonly class fields, and the Definite Assignment Assertion operator (!).

TS Ep 4: Functional TypeScript & Effect-TS Prelude — Immutability, ADTs, and Type-Driven Error Handling

Sun, 09 Aug 2026 14:00:00 +0000

The functional programming masterclass for TypeScript developers. Bridge object-oriented patterns into pure functional architecture with Option/Either types, typed error handling without throw exceptions, pipe/flow composition, and an introduction to the Effect-TS ecosystem.

TS Ep 55: Advanced Function Composition

Sun, 09 Aug 2026 13:45:00 +0000

How do you type a pipe() function that takes an infinite number of functions, where the output of function A must perfectly match the input of function B? Welcome to the final boss of TypeScript.

TS Ep 54: The Builder Pattern with Generics

Sun, 09 Aug 2026 13:40:00 +0000

Learn how to build chainable APIs that accumulate type knowledge at every step. This Generic Accumulator pattern is the secret engine powering libraries like tRPC, Zod, and Prisma, providing unparalleled autocomplete.

TS Ep 53: Branding and Flavoring (Nominal Typing)

Sun, 09 Aug 2026 13:35:00 +0000

TypeScript doesn’t care if two types have different names; if they share the same shape, they are equivalent. Learn how to use Branding and Flavoring to force the compiler to differentiate between an OrderID string and a UserID string, powering Domain-Driven Design.

TS Ep 3: Advanced TypeScript — Conditional Types, Infer Keyword, and Template Literal Metaprogramming

Sun, 09 Aug 2026 13:30:00 +0000

An advanced masterclass in TypeScript type-level metaprogramming. Master conditional types (T extends U ? X : Y), distributive behavior, infer keyword pattern matching for unwrapping types, template literal types (${T}_${U}), and deep recursive object transformations.

TS Ep 52: Variance (Covariance vs Contravariance)

Sun, 09 Aug 2026 13:30:00 +0000

Why is it safe to return a subclass instead of a superclass, but dangerous to accept a superclass parameter instead of a subclass? Welcome to Variance: the computer science underpinning of TypeScript’s assignability engine.

TS Ep 51: Type-Level State Machines

Sun, 09 Aug 2026 13:25:00 +0000

Use mapped types and generics to enforce finite state transitions in the compiler. A type-level state machine makes impossible states impossible to represent, eliminating entire classes of runtime bugs.

TS Ep 50: DeepReadonly and DeepPartial

Sun, 09 Aug 2026 13:20:00 +0000

The built-in Partial and Readonly utilities are shallow. Learn how to write your own DeepReadonly and DeepPartial utilities that penetrate every layer of nested objects by combining Generics, Conditionals, infer, Mapped Types, and Recursion simultaneously.

TS Ep 49: Recursive Types

Sun, 09 Aug 2026 13:15:00 +0000

How do you type a JSON object? A JSON object can contain arrays of objects, which can contain arrays of objects, infinitely down. You cannot hardcode this depth. You need a Recursive Type.

TS Ep 48: String Manipulation Utilities

Sun, 09 Aug 2026 13:10:00 +0000

TypeScript provides four built-in Intrinsic utilities that manipulate the casing of string literal types at compile time. Learn how to pair them with template literals and mapped types to dynamically generate robust event handler mappings.

TS Ep 47: Template Literal Types

Sun, 09 Aug 2026 13:05:00 +0000

Template literal types allow you to use JavaScript-style template strings (${...}) inside Type Space. Learn how to generate combinations of string literals automatically via Union Permutation, and parse delimited strings (like emails or URLs) using the infer keyword.

TS Ep 2: Intermediate TypeScript — Generics, Type Helpers, and Mapped Types

Sun, 09 Aug 2026 13:00:00 +0000

An in-depth guide to intermediate TypeScript type transformations. Master generic functions and constraints (extends), indexed access types, keyof/typeof operators, built-in helpers (Pick, Omit, Record, ReturnType), and mapped type transformations.

TS Ep 46: Inferring Tuples and Arrays

Sun, 09 Aug 2026 13:00:00 +0000

Pattern matching with infer isn’t just for Promises and Objects. You can deconstruct Tuples and Arrays element by element in Type Space, mirroring the exact syntax of JavaScript’s array destructuring and spread operators.

TS Ep 45: Inferring Promises (`Awaited`)

Sun, 09 Aug 2026 12:55:00 +0000

Learn how the built-in Awaited<T> utility models the runtime await keyword. We explore how to combine the infer keyword with Recursive Type Aliases to drill down and unwrap Promises infinitely deep, and how to compose it with ReturnType for async functions.

TS Ep 44: The `infer` Keyword (Pattern Matching)

Sun, 09 Aug 2026 12:50:00 +0000

If conditional types are the if-else statements of Type Space, the infer keyword is the variable declaration (let x = ...). Learn how to extract types dynamically via pattern matching, rebuild ReturnType, and parse Template Literal Strings at compile time.

TS Ep 43: Preventing Distribution (Tuples)

Sun, 09 Aug 2026 12:45:00 +0000

Sometimes, you want a conditional type to evaluate an entire Union as a single monolithic entity, rather than mapping over its individual members. Learn how wrapping generic parameters in brackets [T] prevents distribution, and how to use this mechanic to build complex IsUnion checks.

TS Ep 42: Distributive Conditional Types

Sun, 09 Aug 2026 12:40:00 +0000

When you pass a Union type into a conditional type, TypeScript doesn’t evaluate the union as a whole. It evaluates every single member of the union separately, and combines the results. Learn how this powerful (and sometimes confusing) mechanism powers TypeScript’s standard library.

TS Ep 41: Conditional Types (The Basics)

Sun, 09 Aug 2026 12:35:00 +0000

Conditional types are the if-else statements of Type Space. Learn how to use the ’extends ? :’ syntax to compute dynamic types based on assignability logic, replace complex function overloads, and construct nested else-if type chains.

TS Ep 1: Fundamental TypeScript — Inference, Type Narrowing, and Discriminated Unions

Sun, 09 Aug 2026 12:30:00 +0000

The foundational guide to mastering TypeScript. Learn how the type inference engine works, master type narrowing with typeof, instanceof, in, and custom type predicates (is), build type-safe discriminated unions, and use as const assertions.

TS Ep 40: Key Remapping with `as`

Sun, 09 Aug 2026 12:30:00 +0000

Take your Mapped Types to the absolute limit. Learn how to compute entirely new string names for keys on the fly using Template Literal Types, and discover how to completely filter out properties by returning never during key mapping.

TS Ep 39: Mapped Type Modifiers (`+`, `-`, `?`, `readonly`)

Sun, 09 Aug 2026 12:25:00 +0000

An in-depth guide to Mapped Type Modifiers in TypeScript. Learn how to preserve, add (+), or strip (-) property modifiers like readonly and ?. We explore how these mapping modifiers power TypeScript’s built-in Partial, Required, and Readonly utility types.

TS Ep 38: Mapped Types (Basics)

Sun, 09 Aug 2026 12:20:00 +0000

An in-depth guide to Mapped Types in TypeScript. Learn how to use the [K in Union] syntax to iterate over literal unions, transform existing object properties using keyof and Indexed Access, and build strict state validation maps that perfectly mirror domain models.

TS Ep 37: Built-in Utility Types (`ReturnType` & `Parameters`)

Sun, 09 Aug 2026 12:15:00 +0000

An in-depth guide to ReturnType<T> and Parameters<T>. Learn how to reverse-engineer third-party library functions, the requirement of typeof, tuple indexing to extract specific arguments, and the underlying infer keyword mechanics powering these utilities.

TS Ep 36: Built-in Utility Types (`Extract` and `Exclude`)

Sun, 09 Aug 2026 12:10:00 +0000

An in-depth guide to the Extract and Exclude utility types. Understand the fundamental difference between Object manipulation (Pick/Omit) and Union manipulation (Extract/Exclude), extracting by object signature in discriminated unions, and their underlying distributive conditional type mechanics.

TS Ep 35: Built-in Utility Types (`Record`)

Sun, 09 Aug 2026 12:05:00 +0000

An in-depth look at the Record<K, V> utility type. Learn how to type arbitrary string dictionaries, enforce exhaustive key mapping using Unions, and combine Record with other utilities to model complex domain configurations.

Mastering TypeScript: From Fundamentals to Type-Level Programming & Functional Effect-TS

Sun, 09 Aug 2026 12:00:00 +0000

The ultimate TypeScript masterclass roadmap. Master primitive types, type narrowing, generics, mapped types, conditional types, infer keyword, template literal types, type-level state machines, and functional Effect-TS architecture.

TS Ep 34: Built-in Utility Types (`Pick` and `Omit`)

Sun, 09 Aug 2026 12:00:00 +0000

An in-depth guide to Pick and Omit utility types in TypeScript. Learn under-the-hood mapped type implementations (Pick via mapped types, Omit via Exclude), key constraints differences, building public API DTOs, and the selection decision matrix.

TS Ep 33: Built-in Utility Types (`Partial`, `Required`, `Readonly`)

Sun, 09 Aug 2026 11:55:00 +0000

An in-depth analysis of TypeScript’s foundational object utility types. Learn how Partial<T>, Required<T>, and Readonly<T> transform property modifiers, their under-the-hood mapped type implementations (?, -?, readonly), and shallow immutability limits.

TS Ep 32: Multiple & Dependent Generic Parameters

Sun, 09 Aug 2026 11:50:00 +0000

An in-depth guide to using multiple generic parameters in TypeScript. Learn dependent type parameter relationships, object merging signatures, and how to solve the Partial Generic Inference Trap using higher-order curried functions.

TS Ep 31: Default Generic Arguments (``)

Sun, 09 Aug 2026 11:45:00 +0000

An in-depth guide to Default Generic Arguments in TypeScript. Learn how assigning fallback types (<T = Default>) simplifies generic interfaces, combining constraints with defaults (<T extends Constraint = Default>), and enforcing strict parameter ordering rules.

TS Ep 30: Generic Constraints (`extends` Keyword)

Sun, 09 Aug 2026 11:40:00 +0000

An in-depth guide to Generic Constraints in TypeScript. Learn why unconstrained <T> limits property access, how <T extends Shape> establishes lower type bounds, why generic constraints outperform interface parameter types, and how to constrain keys using <K extends keyof T>.

TS Ep 29: Introduction to Generics — Type Parameters ()

Sun, 09 Aug 2026 11:35:00 +0000

An in-depth introduction to Generics in TypeScript. Learn how type parameters (<T>) bridge reusable logic with strict type safety, generic type inference, generic interfaces (ApiResponse<T>), and generic classes.

TS Ep 28: The `typeof` Type Operator (Value to Type Space)

Sun, 09 Aug 2026 11:30:00 +0000

An in-depth guide to the typeof operator in Type Space. Learn the distinction between Value Space and Type Space, reverse-engineering types from runtime objects and functions, combining keyof typeof, and deriving single-source-of-truth types.

TS Ep 27: The `keyof` Type Operator

Sun, 09 Aug 2026 11:25:00 +0000

An exhaustive guide to the keyof operator in TypeScript. Learn how keyof extracts property key unions from object interfaces, array/tuple types, index signatures, and how to combine keyof with Generics to build type-safe property accessors.

TS Ep 26: Indexed Access Types (`T[K]`)

Sun, 09 Aug 2026 11:20:00 +0000

An in-depth guide to Indexed Access Types (T[K]). Learn how to look up specific property types from object shapes, perform nested indexing, index with unions T['a' | 'b'], extract array element types using [number], and enforce DRY type architectures.

TS Ep 25: Interfaces vs. Type Aliases — The Definitive Comparison

Sun, 09 Aug 2026 11:15:00 +0000

An exhaustive comparison of interface vs type in TypeScript. Understand Declaration Merging, extends vs Intersections (&), compiler performance during type checking, and the precise decision matrix for choosing between them.

TS Ep 15: Immutability with `as const` & Const Assertions

Sun, 09 Aug 2026 11:10:00 +0000

An exhaustive analysis of Const Assertions (as const). Learn the 3 transformation rules of const assertions, deep recursive read-only object properties, converting arrays into readonly tuples, and deriving union types dynamically using typeof ARRAY[number].

TS Ep 14: The Never Type & Exhaustive Checks

Sun, 09 Aug 2026 11:05:00 +0000

An exhaustive deep dive into TypeScript’s bottom type (never). Learn how set theory models the empty set ($mptyset$), the 3 sources of ’never’ in type analysis, and how to implement compile-time exhaustiveness checking for Discriminated Unions.

TS Ep 13: Function Overloads — Polymorphic Signatures

Sun, 09 Aug 2026 11:00:00 +0000

An in-depth guide to Function Overloads in TypeScript. Learn how to define multiple overload signatures, why the implementation signature is invisible to callers, how TypeScript matches overloads sequentially, and when to use Union types instead of Overloads.

TS Ep 12: Function Typing, Call Signatures, and Void Semantics

Sun, 09 Aug 2026 10:55:00 +0000

An exhaustive guide to typing functions in TypeScript. Learn function expressions, type aliases, destructuring parameter signatures, optional/default/rest parameters, call signatures with properties, and why ‘void’ callbacks ignore return values.

TS Ep 11: Discriminated Unions — Tagged Unions & Domain Modeling

Sun, 09 Aug 2026 10:50:00 +0000

An exhaustive guide to Discriminated Unions in TypeScript. Learn why optional property blobs create impossible states, the 3 requirements for tagged unions, how Control Flow Analysis narrows discriminants, and real-world domain state patterns.

TS Ep 10: Custom Type Guards & Assertion Functions

Sun, 09 Aug 2026 10:45:00 +0000

Learn how to build custom runtime type validators in TypeScript. Master Type Predicates (parameter is Type), Assertion Functions (asserts val is Type), array .filter() type narrowing, and safely parsing untrusted external JSON data.

TS Ep 9: Type Narrowing & Control Flow Analysis

Sun, 09 Aug 2026 10:40:00 +0000

Understand how TypeScript’s Control Flow Analysis engine refines types across code branches. Master typeof guards (and the typeof null quirk), instanceof class narrowing, the ‘in’ property operator, equality narrowing, and truthiness pitfalls.

TS Ep 8: Literal Types — Unit Types & Enum Alternatives

Sun, 09 Aug 2026 10:35:00 +0000

An in-depth breakdown of TypeScript Literal Types. Understand unit types in set theory, how string/number literal unions replace Enums with zero runtime overhead, and how to solve object property literal widening bugs.

TS Ep 7: Union and Intersection Types — Set Theory Mechanics

Sun, 09 Aug 2026 10:30:00 +0000

An in-depth analysis of Unions and Intersections in TypeScript. Understand how set theory models type relationships ($A \cup B$ vs $A \cap B$), property access rules, property conflict resolution to ’never’, and operator precedence.

TS Ep 6: Any vs. Unknown — Top Types and Type Safety

Sun, 09 Aug 2026 10:25:00 +0000

Understand the type-system mechanics of top types in TypeScript. Learn why ‘any’ disables type checking and causes type contagion, why ‘unknown’ provides safe dynamic typing, and how to use ‘unknown’ with runtime validation.

TS Ep 5: Arrays, Tuples, and Readonly Collections

Sun, 09 Aug 2026 10:20:00 +0000

An exhaustive guide to typing collections in TypeScript. Learn the syntax differences between T[] and Array, union array typing precedence, labeled tuple elements, rest tuples, and why readonly arrays prevent array mutation bugs.

TS Ep 4: Object Types, Interfaces, and Structural Typing

Sun, 09 Aug 2026 10:15:00 +0000

Learn how to model object shapes in TypeScript. We cover inline types, type aliases, interfaces, optional properties vs undefined, readonly modifiers, index signatures, and TypeScript’s structural type system.

TS Ep 3: Type Annotations vs. Type Inference

Sun, 09 Aug 2026 10:10:00 +0000

Stop writing redundant type annotations. Learn how TypeScript infers types, the mechanics of literal type widening (let vs const), contextual typing in callbacks, and the precise rules for when explicit type annotations are required.

TS Ep 2: Primitive Types — Deep Dive into JS Primitives

Sun, 09 Aug 2026 10:05:00 +0000

An exhaustive breakdown of TypeScript’s 7 primitive types. Learn how TS handles floating-point numbers, BigInts, symbols, strictNullChecks, and the critical structural differences between lowercase primitive types and uppercase Object wrappers.

TS Ep 1: Introduction, Compilation, and Compiler Setup

Sun, 09 Aug 2026 10:00:00 +0000

An in-depth introduction to TypeScript architecture. Understand static type checking vs runtime behavior, the internal stages of the TypeScript compiler (tsc), type erasure, and how to configure tsconfig.json with strict flags for professional development.