Zig in Depth

Introduction: Why Zig?

1. The Systems Programming Landscape Today
2. Andrew Kelley’s Vision and the Origin of Zig
3. No Hidden Control Flow: The Core Philosophy
4. Where Zig Fits Among C, C++, Rust, and Go
5. How This Book Is Organized

Chapter 1: Getting Started - Installation, Toolchain, and Your First Program

1. Installing Zig: Official Releases and Building from Source
2. The Zig Compiler Driver: zig build-exe, zig run, zig test
3. Your First Program: A Walkthrough of main.zig
4. Understanding the Zig Build System (build.zig)
5. Project Layout Conventions and the Standard Library

Chapter 2: Types, Variables, and Constants - The Building Blocks

1. Primitive Types: Integers, Floats, Booleans, and the Void Type
2. Variable Declarations: var vs const and Immutability by Default
3. Type Inference and Explicit Typing
4. Integer Overflow Semantics: Safe, Wrapping, Saturating, and Unchecked
5. The Undefined Behavior Problem Zig Eliminates

Chapter 3: Control Flow - Branching, Looping, and the Block Expression

1. If/Else as Expressions: Values Everywhere
2. The Switch Statement: Exhaustive Pattern Matching Without Patterns
3. While Loops: Tags, Break Values, and Control Flow Clarity
4. For Loops: Arrays, Slices, Enumerators, and the New Syntax
5. Block Expressions and Local Scoping

Chapter 4: Pointers, Arrays, and Slices - Memory in Zig

1. Pointer Types: Single (*T) vs Multi ([*]T) Pointers
2. Const Correctness in Pointers: *const T and Nested Const
3. Arrays as First-Class Value Types: Length Is Part of the Type
4. Slices: Fat Pointers, Bounds Checking, and Ownership Semantics
5. How Zig’s Pointer Model Differs from C

Chapter 5: Structs, Enums, and Unions - Composite Types

1. Struct Definitions: Fields, Default Values, and Initialization
2. Methods and the Self Parameter
3. Enums: Values, Tags, Sentinels, and Iteration
4. Unions and Tagged Unions (union(enum)): Safe Variant Types
5. Packed Structs and Extern Structs for Binary Layout Control

Chapter 6: Optionals, Error Sets, and Error Unions - Safety Without Exceptions

1. Optionals: The T? Type and Safe Null Handling
2. Error Sets as Compile-Time Types
3. The try Operator: Propagating Errors Explicitly
4. Error Unions (T!E) and the catch Operator
5. errdefer: Cleanup on Error Return
6. Why Zig Rejects Exceptions: Design Rationale

Chapter 7: Functions, Generics, and Compile-Time Programming - Zig’s Superpower

1. Function Declarations: Parameters, Return Types, and Conventions
2. Inline Functions and Call-Site Inlining
3. The comptime Keyword: When Code Runs at Compile Time
4. Type Parameters and Generic Functions
5. Building Generic Data Structures: A Linked List from Scratch
6. Comptime Blocks and Compile-Time Assertions

Chapter 8: Memory Management - Explicit Allocation, No Garbage Collector

1. The Allocator Parameter: Passing Memory Responsibility Explicitly
2. GeneralPurposeAllocator and the Standard Library Allocators
3. ArenaAllocator: Scope-Based Allocation for Temporary Data
4. FixedBufferAllocator and Stack-Backed Allocation
5. Manual Memory Management Patterns and Common Mistakes

Chapter 9: Strings, Formatting, and I/O - Working with Text

1. Strings Are UTF-8 Byte Slices: Encoding Semantics
2. String Comparison, Concatenation, and Allocation-Free Operations
3. Formatting: std.fmt Formatters and Custom Format Implementations
4. File I/O: Readers, Writers, and the Buffering Layer
5. Path Handling and Directory Traversal

Chapter 10: The Build System, Package Management, and C Interop

1. The Build System (build.zig) in Depth: Steps, Options, and Artifacts
2. Cross-Compilation: Zig’s Built-In Multiplatform Story
3. Module System and Package Management
4. Importing C Libraries: Build-System C Translation
5. Exporting to C: FFI in the Other Direction

Chapter 11: Testing, Debugging, and Tooling - Building Reliable Software

1. The Built-In Test Framework: zig test and Test Organization
2. Assertion Macros and Custom Error Messages
3. Debugging with GDB and LLDB
4. Sanitizers: AddressSanitizer, UndefinedBehaviorSanitizer, and ThreadSanitizer
5. Profiling and Performance Analysis Tools

Chapter 12: Concurrency - Threads, Atomics, and Synchronization

1. Threads: std.Thread and the Spawn API
2. Atomic Operations: Load, Store, Compare-and-Swap, and Ordering
3. Mutexes, RWLocks, and Condition Variables
4. Channel-Based Communication Patterns
5. Concurrency Pitfalls and Safe Patterns

Chapter 13: Real-World Projects - Case Studies in Idiomatic Zig

1. Case Study 1: Building a Command-Line JSON Parser
2. Case Study 2: A Simple HTTP Server from Scratch
3. Case Study 3: A Binary Protocol Encoder and Decoder
4. Project Structure Best Practices for Larger Codebases
5. Performance Optimization: Benchmarking, Profiling, and Tuning

Conclusion: The Zig Journey Ahead

References