Zig From Zero
By External Provider
About this course
By the end of this course you will read Zig source confidently, build static binaries small enough to ship inside a 50-kilobyte microcontainer, pick the right allocator (GeneralPurposeAllocator, ArenaAllocator, FixedBufferAllocator, or page_allocator) for each workload, and tell a data engineering team where Zig wins versus where Rust still owns the problem. The course is pitched at Rust developers. Every Zig idiom is paired with the Rust pattern it replaces — allocator parameters versus `'a` lifetimes, the `!T` error type versus `Result`, `comptime T: type` versus trait bounds plus `derive` plus `macro_rules!`, and `defer` plus `errdefer` versus `impl Drop`. You finish with a clear mental model of when to reach for Zig (Lambda, edge, embedded, C interop) and when to stay with Rust (long-running services with shared state). Six modules cover the language tour, performance optimization, a Marco Polo CLI, four allocator strategies side by side, a Docker multi-stage build for a Zig HTTP server, and the Rust-or-Zig decision rule on a real data team.
What you will learn
- Read and write Zig — including the four standard-library allocators (GPA, Arena, FixedBuffer, page_allocator) — and map each idiom back onto Rust
- Build a tiny statically-linked Zig binary and ship it inside a multi-stage Dockerfile that produces a kilobyte-sized container image
- Make the language choice on a real team — pick Zig for footprint, fast cold start, and C interop; stay with Rust for long-running services