How to Actually Learn Zig (2027 Edition)

Main ideas, concepts, and lessons

• Zig’s motivation vs. C/C++

  • Zig is presented as a systems programming language that aims to:
    • Keep the power of C (low-level control).
    • Improve C’s weaknesses by being explicit about behavior that C (and hidden layers) often obscure.
  • The video contrasts “dogma” and complexity in other languages (e.g., references to OOP/C++ pipelines) with Zig’s emphasis on data-oriented, explicit control.
  • Core Zig principles emphasized:
    • No hidden allocators
    • No hidden control flow
    • Avoids “borrow checker” and classes
    • Makes resource management and effects visible

• Explicitness as a debugging/safety advantage

  • Many “easy” behaviors in C (like output buffering, flushing, and allocation management) are described as being handled implicitly by libraries.
  • Zig is framed as harder to misuse because you must explicitly handle allocations, errors, buffering, and flushing, reducing “bugs hiding dormant” compared to C/C++.

• Demonstration project: rebuild a simplified sort pipeline in Zig

  • The tutorial incrementally builds a Zig program that:
    1. Prints text
    2. Reads lines from a file (line-by-line)
    3. Stores those lines
    4. Sorts them alphabetically
    5. Outputs results to a file/standard output
  • The final result is compared to GNU sort, claiming equivalent behavior for the simple alphabetical sort used.

---

Methodology / step-by-step instructions (as shown in the subtitles)

A) Set up and run a basic Zig file

• Install/obtain required tools:
  • Zig version 16
  • A text editor (example: nvim)
  • Optionally an LSP: ZLS
• Create a file:
  • sort.zig
• Basic imports:
  • const std = @import("std");
  • (Described as Zig’s import system using const + @import.)
• Define main:
  • Start with: pub fn main() void (no args)
• Print a basic message using debug printing:
  • std.debug.print("...", .{})
  • Note:
    • std.debug.print expects formatting arguments.
    • Use an empty args list (e.g., .{}) when no parameters are passed.

---

B) Understand why output redirection appears empty

• Symptom shown:
  • Running: zig run sort.zig > zigout.txt results in an empty file.
• Explanation:
  • std.debug.print writes to standard error (stderr), not standard output (stdout).
  • It also uses a 64-byte buffer for formatted printing and flushes it before return, making it a “debug tool” rather than a normal output stream.

---

C) Switch from debug printing to real stdout writing

• Use Zig’s standard library I/O instead of std.debug.print.
• Key changes:
  • Modify main to allow error returns:
    • Use !void (an error union).
  • Access process-provided I/O and an allocator via main parameter:
    • Pass in std.process (described as: main receives std.process.init).
    • This provides default IO and an allocator (GPA).
• Construct a stdout writer pipeline:
  • Create:
    • A stdout file handle (referred to as std.io.file.*standard out*)
    • A 4 KiB scratch buffer:
      • var buffer: [4096]u8 = undefined;
  • Use a writer derived from:
    • the stdout file handle
    • the process IO
    • the scratch buffer (as a slice)
• Print and flush explicitly:
  • Use output.print(...) (instead of debug print)
  • Wrap with try to handle errors:
    • try output.print(...)
  • Flush explicitly:
    • try output.flush()

---

D) Read input line-by-line (rebuild the “cat” part first)

• Reuse a similar explicit I/O setup for standard input:
  • Create two buffers, explicitly separated:
    • outbuff for output and inbuff for input (both 4 KiB)
  • Create a reader:
    • std.io.reader for standard in, using init IO and inbuff
• Split input by delimiter:
  • Use a documented function:
    • takeDelimiter(reader, '\n')
• Control flow structure described:
  • A while loop that continues while a line is returned
  • Loop terminates when the function returns null (EOF)
• Error handling:
  • try is required inside the loop because delimiter reading can error.
  • For now, output each line to stdout, plus flush.

---

E) Store lines so they can be sorted

• Create a growable array list of strings:
  • Use std.ArrayList([]const u8) (described as a contiguous growable list)
  • Example creation:
    • var lines = std.ArrayList([]const u8).init(empty allocator...)
    • Allocator details are filled in via GPA from process.init.
• Append each read line:
  • Replace printing with:
    • try lines.append(gpa, line)

• Free memory explicitly:

  • Use defer for cleanup:
    • defer lines.deinit(gpa);

• Important buffer lifetime issue (critical):

  • takeDelimiter returns a slice pointing into the input buffer.
  • That input buffer is reused, so storing the slice directly will corrupt stored lines later.
• Fix by copying each line (“own” the data):
  • For each line read:
    • const owned = try gpa.dupe(u8, line) (duplicate/copy)
  • Append the copied/owned slice instead:
    • try lines.append(gpa, owned)
• Cleanup strategy:
  • Use a defer block with a loop to free each owned line, since each duplication allocates per line:
    • free each element
    • then lines.deinit(gpa)

---

F) Sort stored lines

• Use Zig’s standard sort:
  • std.sort.sort(T, items, context, lessThanFn)
• Comparator function:
  • Defined outside main, e.g.:
    • fn lessThan(_: void, a: []const u8, b: []const u8) bool { return std.sort.lessThan(u8)(a, b); }
  • The intended meaning:
    • return true when a < b
    • uses alphabetical string comparison
• Call sort after reading is complete:
  • Sort lines.items using:
    • element type: const u8 (slices)
    • context: {}
    • comparator: lessThan
• Test:
  • Feed distros.txt into the program
  • Confirm alphabetically sorted output
  • Show that the output matches GNU sort for the simple case

---

G) Final takeaways emphasized by the video

• Allocation is explicit: every allocation is made visible to the programmer.
• In contrast, C++ abstracts away allocator and lifecycle details via hidden mechanisms (described as “more or less the whole pitch of Zig”).
• Zig is framed as “C leveled up” by increasing explicitness rather than hiding complexity.

---

Sources / speakers featured

• Tony (speaker; host of the tutorial)
• Dennis Richie (referenced historically as creating C; historical reference only)
• Andrew Kelly (referenced as influencing/associated with Zig; historical/person reference only)
• GNU sort (referenced as the comparison target)
• Zig documentation (referenced for debug output and writer/stdout functions)
• GitHub issue (referenced as the lead/source for std.process.init usage; not otherwise identified)