Systems Programming with Zig, Garrison Hinson-Hasty, Manning Publications (available in early access)

I love programming languages. Any new book about a programming language makes me happy. I also love operating systems and systems programming. Why systems programming? It feels like serious stuff, no bullshit, down to earth, no JSON tossing here and there. Now I’ve got a book on systems programming that is also an introduction to the Zig programming language. Could I avoid reviewing it? I don’t think so.

The Systems Programming with Zig book has not been published yet; it recently entered Manning’s Early Access program, and there are only three chapters available. But you know what? That’s enough for me to figure out that it’s doomed to be a great book, one that holds your attention and helps you learn.

A quick glance at the table of contents reveals that the author is using a project-based approach. Language concepts are introduced when they are actually needed and where they can make a difference. It’s not an easy thing to start building something real when the reader doesn’t know anything about the language, but it seems that the author nailed it right. In that sense, Chapter 3 is a masterpiece, but let me first tell you about the first two chapters.

Can you think of what the title of the 1.1.1 subsection could be? “Zig AI”. Well, these days, if one is not writing about AI, they need to justify their right to exist: LLMs are not that good at systems programming and novel programming languages so far. Section 1.2 promotes Zig as a collaborator, not a successor or a killer of other programming languages. Smart move, you know. I heard about other programming languages that were advertised in a bit of a different way and invited a lot of haters. Subsection 1.5.4 is called “Explore, don't copy”. It teaches a reader how to properly work on the book and the code examples to learn the most. Good advice, it’s all about exploration and self-experimentation. Developer experience, appropriate application domains for Zig, and getting started with the (not so simple) program are other topics of the first chapter.

Chapter 2 introduces traditional language concepts without too many details, such as basic types, functions, arrays, pointers (it’s systems programming after all!), and structs. Maybe it’s not a piece of cake, but it’s definitely a good loaf of bread, something essential you need to figure out first when you start learning a programming language.

Chapter 3: We’re implementing the cat utility. Boring? Not at all, because here’s what the author is doing:

• All right, we need to be able to read and write files. Hence, we talk about readers and writers.

• Okay, since we don’t know file sizes, we need to use heap memory. So, we learn about allocators, a way to access memory in Zig, and byte buffers (that’s what they use instead of JSONs in systems programming).

• Readers, writers, and allocators all follow the general Zig pattern of interfaces and VTables. It’s an advanced topic, so let’s not dive into details, but at least you’ll know that there’s something interesting here.

• Working with operating system resources can lead to many different errors at run time, so it seems like the right time to discuss error handling in Zig.

• Are systems different in their requirements and limitations regarding memory and speed? Sure. As a result, we discuss build scripts, optimization levels, comptime (meta) programming, and even generating a module to give access to parameters specified when building the executable. Hey, we’re at chapter 3! We’ve just started! And yes, this is amazing.

I wish I had more to read and learn from the author. I’m definitely waiting for more chapters to become available. Of course, I recommend reading this book even if you don’t plan to write code in Zig. It’s not about coding; it’s about great ideas in programming language designs. What can be more captivating?