JavaScript parece estar deshabilitado en tu navegador. Para la mejor experiencia en nuestro sitio, asegúrate de activar JavaScript en tu navegador.

SKU/Artículo: AMZ-B0G1PPLDW4

Zig Async Programming: Explicit Control: A Practical Guide to async, await, and Evented I/O for High-Performance Systems.

Format:

Kindle

Hardcover

Kindle

Paperback

Detalles del producto

Disponibilidad:
Fuera de stock

Peso con empaque:
0.94 kg

Devolución:
No

Condición
Nuevo

Producto de:
Amazon

Viaja desde
USA

Sobre este producto

In a world of "magic" runtimes, modern concurrency often feels like a black box. We are given simple keywords like go or await and are told to "just trust" the hidden, complex schedulers that run our code. This works, until it does not. When a high-performance application has a mysterious latency spike or a hard-to-debug memory leak, we find ourselves fighting an opaque system we do not understand and cannot control. This book is the antidote. It is a practical, "first-principles" guide to Zig's revolutionary approach to asynchronous programming, which is built entirely on the philosophy of Explicit Control. This is not a book of high-level abstractions; it is a journey of deconstruction. We will systematically dismantle Zig's async/await model to prove that there is no magic. You will not just use an event loop; you will build one from scratch, from the raw OS-level system calls (epoll, kqueue) all the way up. This guide will lead you to the "Aha!" moment: an async function in Zig is not a "green thread." It is a brilliant, language-level transformation that refactors your function into a simple, passive state machine struct. You will learn to see await not as a magical command, but as a simple "suspension point" in a machine that you explicitly drive. Through this book, we will:Master the async Frame: Learn why an async frame is just a struct (not a stack) and how this design choice leads to massive memory and performance gains.Build an Event Loop: Go beyond just using std.event.Loop. We will build our own "engine" from scratch in Chapter 4, proving you do not need a runtime—you are the scheduler.Solve the C10k Problem: Apply our knowledge to build a practical, non-blocking TCP server capable of handling 10,000+ simultaneous connections, mastering the "self-freeing" allocator pattern for total memory control.Bridge the Two Worlds: Confront the "cardinal sin" of blocking the event loop. We will master the hybrid architecture, learning when to use async (for I/O-bound work) and when to offload "sinful" CPU-bound work to a std.Thread, bridging the two with a thread-safe std.async.Queue.Profile Like an Expert: Learn to debug and profile event-driven systems. We will use perf and custom instrumentation to answer the most critical question: "Am I CPU- or I/O-bound?"This book is for any systems programmer, or any developer from a "magic" runtime language (like Go, Rust, or C#), who is tired of guessing. It is for those who crave a deeper, mechanical understanding of their concurrent systems. By the time you finish, you will not just use Zig's async model; you will have mastered it. You will be able to build high-performance, event-driven applications with absolute confidence, because you will have proven to yourself that there is no hidden scheduler. There is only your code, your event loop, and your explicit control.

Fuera de stock

Selecciona otra opción o busca otro producto.

Medios de pago

Aceptamos múltiples medios de pago para tu comodidad

Tarjetas prepagas, débito y crédito