TypeScript Programming Course

Lesson 1 • Writing and Compiling Your First Program

A simple typed program is written, compiled, and executed to confirm the environment works. Students observe how type errors surface before runtime.

Lesson 2 • Installing and Configuring the Toolchain

Node.js, npm, and the TypeScript compiler are installed and verified. Students create a project scaffold used throughout the course.

Lesson 3 • What TypeScript Is and Why It Matters

TypeScript's relationship to JavaScript, its compile-to-JS model, and the benefits of static typing are introduced. This context motivates every subsequent language feature.

Lesson 1 • Type Aliases and Union Types

Custom named types and union combinations allow flexible yet safe variable definitions. Students model real-world data that can hold multiple forms.

Lesson 2 • Arrays and Tuple Types

Typed arrays and fixed-length tuples are declared and manipulated. These structures underpin collections used in every subsequent chapter.

Lesson 3 • Special Types: null, undefined, void, never

Edge-case types that represent absence, no return, or impossible states are defined and contrasted. Understanding these prevents null-reference bugs in later code.

Lesson 4 • Literal Types and Enums

Literal string and numeric types constrain values to exact sets, while enums group named constants. Both techniques reduce magic strings and numbers in codebases.

Lesson 1 • Typing Function Parameters and Return Values

Every parameter and return value is explicitly annotated to prevent misuse. This section establishes the discipline applied to all functions in the course.

Lesson 2 • Function Overloads

Overload signatures allow one function to accept multiple distinct call shapes safely. Students implement overloads to replace unsafe any-based polymorphism.

Lesson 3 • Function Types and Signatures

Functions are treated as first-class values with their own type signatures. Students pass and return typed functions in callbacks and higher-order patterns.

Lesson 1 • Nested and Recursive Object Types

Complex data structures with nested objects and self-referential shapes are typed safely. This skill is essential for modelling trees, graphs, and API responses.

Lesson 2 • Defining Interfaces

Interfaces declare the shape of objects with named properties and their types. They form the primary contract mechanism used throughout TypeScript codebases.

Lesson 3 • Interface Extension and Merging

Interfaces extend other interfaces to build hierarchies, and declaration merging adds properties across files. Students leverage both to model complex domain objects.

Lesson 1 • Access Modifiers and Encapsulation

public, private, protected, and readonly modifiers control member visibility and mutability. Proper encapsulation prevents unintended state mutation across class hierarchies.

Lesson 2 • Static Members and Mixins

Static properties and methods belong to the class itself rather than instances, and mixins compose behaviour across unrelated classes. Both patterns appear frequently in large codebases.

Lesson 3 • Inheritance and Method Overriding

Subclasses extend base classes and override methods with compatible signatures. Students build a multi-level hierarchy and observe how TypeScript enforces override correctness.

Lesson 4 • Abstract Classes and Interfaces

Abstract classes define partial implementations that subclasses must complete, while interfaces define pure contracts. Students choose between them based on design requirements.

Lesson 1 • Generic Constraints

The extends keyword constrains type parameters to shapes that possess required properties. Constraints prevent runtime errors while preserving generic flexibility.

Lesson 2 • Utility Types Built on Generics

Built-in utility types such as Partial, Required, Readonly, Pick, and Omit are applied to transform existing types. Students recognise these as generic patterns they can replicate.

Lesson 3 • Generic Interfaces and Type Aliases

Interfaces and type aliases accept type parameters to describe reusable data shapes. Students build generic container and response types used across modules.

Lesson 4 • Generic Functions

Type parameters are added to functions so callers supply the concrete type at use. Students replace any-based utilities with fully type-safe generic equivalents.

Lesson 1 • Mapped Types

Mapped types iterate over union keys to transform every property of an existing type. Students build custom utility types equivalent to the built-in helpers.

Lesson 2 • Type Inference with infer and ReturnType

The infer keyword extracts type components from complex types inside conditional branches. Students build utilities that derive parameter and return types automatically.

Lesson 3 • Discriminated Unions and Exhaustiveness

Tagged union types with a shared discriminant property enable safe, exhaustive pattern matching. Students model state machines and API responses with zero unsafe casts.

Lesson 4 • Template Literal Types

String types are constructed programmatically by combining literal types with template syntax. Students type event names, CSS properties, and API routes at the type level.

Lesson 1 • Declaration Files and DefinitelyTyped

d.ts files describe the types of JavaScript libraries that lack built-in TypeScript support. Students consume community types and author minimal declarations for untyped packages.

Lesson 2 • Namespaces and Legacy Module Patterns

Namespaces group related declarations under a single identifier, a pattern common in older codebases. Students recognise namespace code and migrate it to ES modules.

Lesson 3 • ES Module Syntax in TypeScript

import and export statements are typed and configured for various module systems. Students understand how TypeScript resolves modules and emits compatible JavaScript.

Lesson 4 • Module Resolution and Path Aliases

TypeScript's module resolution algorithms and tsconfig path mappings eliminate brittle relative imports. Students configure aliases that survive project restructuring.