دانلود کتاب برنامه‌نویسی سیستم‌ها با Zig – ساخت ابزارهای واقعی بدون هزینه پنهان

Welcome to the 1st Edition of Systems Programming with Zig! Systems programming has always been a discipline defined by honesty. Honest about what the hardware can do. Honest about where the memory came from and where it goes. Honest about the cost of every abstraction. For decades, C was the language that embodied that honesty — not because it was elegant but because it hid almost nothing. You saw the pointers. You managed the memory. You felt the machine beneath your fingers. Zig carries that tradition forward but it does something C never quite managed: it makes the honest path also the convenient one. There is no hidden control flow. There is no global allocator quietly doing work on your behalf. There is no runtime making decisions you did not ask for. What you write is what runs, and the compiler will tell you — loudly, at build time — when what you wrote does not match what the machine requires. That quality, that refusal to let complexity hide in corners, is what makes Zig a genuinely interesting language for systems work rather than merely another contender. This book is for programmers who want to understand systems, not just use them. We assume you can read Zig code and navigate a UNIX terminal. What we do not assume is that you already know why a TCP echo server blocks on accept(), what the kernel I/O scheduler is doing while your buffered writer accumulates bytes or why the wrong allocator choice in a hot loop can cost you an order of magnitude in throughput. Those are the questions this book is built around. We build real tools throughout. A tee(1) clone, a Zip file lister, a file watcher backed by platformspecific kernel primitives, a concurrent job scheduler, a production-grade in-memory cache with a custom binary protocol, a note-taking service backed by SQLite3, and, finally, a working interpreter for a small programming language built from scratch. These are not toy examples dressed up as projects. They are the kind of programs that force you to make architectural decisions, feel the consequences of those decisions in the benchmark output, and understand why the systems community settled on the patterns it did. In the tradition of foundational texts such as The UNIX Programming Environment and The C Programming Language, we frequently pause to examine the why. When we introduce a mutex, we explain what goes wrong without one. When we choose an arena allocator, we benchmark the alternative. When we design a binary protocol, we show what comptime can enforce that a runtime check cannot. The code is a vehicle for understanding engineering tradeoffs, and those tradeoffs are the real curriculum. Zig 0.16.x arrived with significant changes — new I/O abstractions, a renamed allocator, a reworked networking API — and this book is written against that version throughout. Every code listing compiles and runs on Zig 0.16.0. Where the language made an interesting choice or broke with an older convention, we say so explicitly, because understanding why a language evolves is part of understanding the language. Systems programming is not a finishing school for programmers who have mastered everything else. It is a way of thinking — about resources, about time, about the gap between what you asked the machine to do and what it actually did. Zig is an exceptionally clear lens for developing that way of thinking, because it refuses to blur the picture. Thank you for choosing and reading Systems Programming with Zig. Let us dive in and unlock the full potential of Zig together! Happy coding! Soli Deo gloria Who this book is for This book is for programmers who already understand Zig at a basic level and want to use it to do serious systems work, as well as intermediate and experienced systems programmers in Go, Python, Java, C, C++ or Rust who are curious about what Zig brings to the discipline. You do not need to be a Zig expert — a working familiarity with the syntax, the type system, and the basic standard library is enough to follow every chapter from the start. If you have written application code in higher-level languages and are making your first serious contact with systems programming, some sections will challenge you. The chapters on memory allocators, data structures, and binary protocol parsing in particular assume a willingness to sit with unfamiliar ideas before they fully resolve. A second reading of a difficult section often reveals details that were invisible the first time through. That is not a failure of comprehension — it is how systems knowledge accumulates. Throughout the book, you will find working programs, benchmark results, and exercises grounded in real problems. The tools we build — a job scheduler, a file indexer, a cache server, an interpreter — are not simplified illustrations of the concepts. They are the concepts, expressed in code that compiles and runs. Read them, run them, modify them, break them, and observe what changes! Passive reading will take you only so far in systems programming. Finally, be prepared for the compiler to argue with you, for benchmarks to produce surprising numbers, and for bugs to hide in places that seem unrelated to where you made the change. This is not a sign that you are doing something wrong. It is the nature of the discipline. Systems programming is an ongoing negotiation between your intentions and the machine’s reality, and Zig is unusually honest about where the gaps are. That honesty is uncomfortable at first and invaluable thereafter.