Zig Programming Language Course

Lesson 1 • The Zig Build System Basics

Introduces the zig build command, build.zig files, and compilation targets. Connects toolchain knowledge to practical project creation.

Lesson 2 • Installing and Configuring Zig

Guides installation of the Zig toolchain on major operating systems and configures editor support. Ensures a reproducible build environment from day one.

Lesson 3 • Zig's Design Philosophy and Goals

Covers Zig's core principles: no hidden control flow, no hidden allocations, and comptime-first design. Sets context for every decision made throughout the course.

Lesson 1 • Operators and Expressions

Surveys arithmetic, bitwise, comparison, and logical operators with their overflow behavior. Connects operator semantics to Zig's no-undefined-behavior guarantee.

Lesson 2 • Primitive Types and Type Inference

Covers integers, floats, booleans, and the comptime_int/comptime_float types. Explains how Zig infers types and when explicit annotation is required.

Lesson 3 • Optionals and Error Unions

Introduces ?T optional types and !T error union types as first-class control flow tools. Prepares students for Zig's error-handling model introduced in the next chapter.

Lesson 4 • Variables, Constants, and Mutability

Distinguishes var from const and explains Zig's immutability-by-default approach. Reinforces explicit control over data mutation.

Lesson 1 • Structs and Methods

Defines struct types, field access, and method syntax using the self parameter convention. Shows how structs serve as Zig's primary encapsulation mechanism.

Lesson 2 • Defining and Calling Functions

Covers function syntax, parameter passing, return types, and inline functions. Establishes the foundation for all abstraction in subsequent chapters.

Lesson 3 • Enums and Tagged Unions

Teaches enum declaration, methods on enums, and tagged unions for sum types. Connects to exhaustive switch matching covered in the previous chapter.

Lesson 1 • Slices and Arrays

Distinguishes fixed-size arrays from runtime slices and explains fat-pointer semantics. Connects to safe iteration patterns introduced in Chapter 2.

Lesson 2 • Memory Safety Patterns

Covers defer for cleanup, ownership conventions, and avoiding use-after-free. Reinforces Zig's philosophy of explicit, auditable memory management.

Lesson 3 • Pointers and Pointer Types

Covers single-item pointers, many-item pointers, and const pointers with their syntax. Builds precise mental models before introducing heap allocation.

Lesson 4 • The Allocator Interface

Explains the std.mem.Allocator interface and why Zig passes allocators explicitly. Establishes the pattern used by all standard library data structures.

Lesson 1 • Comptime Evaluation Deep Dive

Explores how Zig evaluates comptime blocks, comptime variables, and comptime loops. Builds intuition for what runs at compile time versus runtime.

Lesson 2 • Type Reflection with @typeInfo

Uses @typeInfo, @TypeOf, and @typeName to inspect types at compile time. Enables writing code that adapts to arbitrary struct or enum layouts.

Lesson 3 • Generic Functions and Types

Shows how to write functions and structs parameterized by comptime type arguments. Connects to struct and function knowledge from Chapter 3.

Lesson 4 • Comptime String and Code Generation

Uses comptime to generate struct fields, dispatch tables, and string-based APIs. Demonstrates metaprogramming patterns common in serialization and RPC libraries.

Lesson 1 • try, catch, and errdefer

Demonstrates try for propagation, catch for local handling, and errdefer for cleanup on failure. Connects error handling to the memory safety patterns from Chapter 4.

Lesson 2 • Panics, Assertions, and Unreachable

Explains @panic, std.debug.assert, and unreachable for invariant enforcement. Distinguishes recoverable errors from programming bugs.

Lesson 3 • Error Sets and Error Unions

Defines named error sets, inferred error sets, and error union return types. Establishes the vocabulary for all error-handling patterns in this chapter.

Lesson 1 • Testing with std.testing

Uses std.testing.expect, expectEqual, and expectError to write unit tests. Establishes a test-driven workflow for all subsequent project work.

Lesson 2 • Concurrency with Threads and Atomics

Introduces std.Thread, mutexes, and atomic operations for shared-state concurrency. Prepares students for systems programming tasks requiring parallelism.

Lesson 3 • Strings and Unicode Handling

Explains Zig's byte-slice string model, UTF-8 iteration, and std.fmt formatting. Addresses common pitfalls when working with text data.

Lesson 4 • I/O and File System Operations

Covers std.io readers and writers, file opening, reading, and writing. Connects allocator patterns from Chapter 4 to buffered I/O streams.

Lesson 1 • Embedded and Freestanding Targets

Configures Zig for freestanding targets, disables the standard library, and writes startup code. Demonstrates Zig's suitability for bare-metal and embedded development.

Lesson 2 • Calling C from Zig

Covers @cImport, translating C headers, and linking against C libraries. Enables reuse of the vast C ecosystem from within Zig projects.

Lesson 3 • Exposing Zig to C

Teaches export, extern, and C ABI compatibility for building Zig libraries consumed by C. Completes the bidirectional interop picture.

Lesson 4 • Cross-Compilation and Deployment

Uses Zig's built-in cross-compiler to target multiple architectures from a single host. Produces optimized, statically linked binaries ready for deployment.