There's a question that's always been asked by systems programmers working in C++ and those working in Rust. Is there a way to control systems that doesn't mean choosing between power and predictability? Zig represents that path.
The idea is pretty clear as really there's no such thing as hidden behaviour. Everything's totally clear about each allocation. Every error is given a name and can be found in the type system. So, every piece of control flow is going to appear at the call site. The programmer always knows what the program does, because the language won't act without instruction. This book teaches Zig through a project-based approach centred on a single growing systems toolkit.
This book gives you hands-on experience with Zig's allocator model, generic programming through comptime, typed error handling, filesystem and process management, concurrent threads and atomic state, and HTTP server construction, with each concept built on the one before it.For C++ developers, Zig gets rid of undefined behaviour and preprocessor complexity without sacrificing machine-level access. For Rust developers, it's got a simpler ownership model, no borrow checker friction, and a C interoperability path that doesn't need a binding generator. You'll see that both communities have familiar systems programming patterns expressed in a language that carries none of their respective historical weight.
Die Inhaltsangabe kann sich auf eine andere Ausgabe dieses Titels beziehen.
Anbieter: Grand Eagle Retail, Bensenville, IL, USA
Paperback. Zustand: new. Paperback. There's a question that's always been asked by systems programmers working in C++ and those working in Rust. Is there a way to control systems that doesn't mean choosing between power and predictability? Zig represents that path.The idea is pretty clear as really there's no such thing as hidden behaviour. Everything's totally clear about each allocation. Every error is given a name and can be found in the type system. So, every piece of control flow is going to appear at the call site. The programmer always knows what the program does, because the language won't act without instruction. This book teaches Zig through a project-based approach centred on a single growing systems toolkit.This book gives hands-on experience with Zig's allocator model, generic programming through comptime, typed error handling, filesystem and process management, concurrent threads and atomic state, and HTTP server construction, with each concept built on the one before it.For C++ developers, Zig gets rid of undefined behaviour and preprocessor complexity without sacrificing machine-level access. For Rust developers, it's got a simpler ownership model, no borrow checker friction, and a C interoperability path that doesn't need a binding generator. You'll see that both communities have familiar systems programming patterns expressed in Zig that carries none of their respective historical weight.Key FeaturesWrite memory-safe systems code without garbage collector or borrow checker overhead.Control heap allocation using Zig's transparent allocator interface.Build compile-time generic data structures with zero runtime overhead.Handle errors through typed error sets.Interoperate with C libraries directly without binding generators or wrapper layers.Cross-compile production binaries with a single build command.Coordinate concurrent threads safely using Mutex, atomic values, and condition variables.Model data with exhaustive enums and tagged unions.Inspect and manipulate raw memory through typed slices, packed structs, and pointers.Deploy release binaries using Zig's 3 configurable build modes.Table of ContentGetting Started with ZigExploring Zig CodesAllocation, Safety, and Data StructuresGenerics, Reflection, and ToolchainFiles, Processes, and NetworksThreads, Shared State, and CoordinationOptimisation and DeploymentAdvanced Patterns This item is printed on demand. Shipping may be from multiple locations in the US or from the UK, depending on stock availability. Bestandsnummer des Verkäufers 9789349174115
Anbieter: California Books, Miami, FL, USA
Zustand: New. Bestandsnummer des Verkäufers I-9789349174115
Anzahl: Mehr als 20 verfügbar
Anbieter: PBShop.store US, Wood Dale, IL, USA
PAP. Zustand: New. New Book. Shipped from UK. Established seller since 2000. Bestandsnummer des Verkäufers L2-9789349174115
Anzahl: Mehr als 20 verfügbar
Anbieter: PBShop.store UK, Fairford, GLOS, Vereinigtes Königreich
PAP. Zustand: New. New Book. Shipped from UK. Established seller since 2000. Bestandsnummer des Verkäufers L2-9789349174115
Anzahl: Mehr als 20 verfügbar
Anbieter: BuchWeltWeit Ludwig Meier e.K., Bergisch Gladbach, Deutschland
Taschenbuch. Zustand: Neu. This item is printed on demand - it takes 3-4 days longer - Neuware 134 pp. Englisch. Bestandsnummer des Verkäufers 9789349174115
Anzahl: 2 verfügbar
Anbieter: AHA-BUCH GmbH, Einbeck, Deutschland
Taschenbuch. Zustand: Neu. nach der Bestellung gedruckt Neuware - Printed after ordering - There's a question that's always been asked by systems programmers working in C++ and those working in Rust. Is there a way to control systems that doesn't mean choosing between power and predictability Zig represents that path.The idea is pretty clear as really there's no such thing as hidden behaviour. Everything's totally clear about each allocation. Every error is given a name and can be found in the type system. So, every piece of control flow is going to appear at the call site. The programmer always knows what the program does, because the language won't act without instruction. This book teaches Zig through a project-based approach centred on a single growing systems toolkit.This book gives hands-on experience with Zig's allocator model, generic programming through comptime, typed error handling, filesystem and process management, concurrent threads and atomic state, and HTTP server construction, with each concept built on the one before it.For C++ developers, Zig gets rid of undefined behaviour and preprocessor complexity without sacrificing machine-level access. For Rust developers, it's got a simpler ownership model, no borrow checker friction, and a C interoperability path that doesn't need a binding generator. You'll see that both communities have familiar systems programming patterns expressed in Zig that carries none of their respective historical weight.Key FeaturesWrite memory-safe systems code without garbage collector or borrow checker overhead.Control heap allocation using Zig's transparent allocator interface.Build compile-time generic data structures with zero runtime overhead.Handle errors through typed error sets.Interoperate with C libraries directly without binding generators or wrapper layers.Cross-compile production binaries with a single build command.Coordinate concurrent threads safely using Mutex, atomic values, and condition variables.Model data with exhaustive enums and tagged unions.Inspect and manipulate raw memory through typed slices, packed structs, and pointers.Deploy release binaries using Zig's 3 configurable build modes.Table of ContentGetting Started with ZigExploring Zig CodesAllocation, Safety, and Data StructuresGenerics, Reflection, and ToolchainFiles, Processes, and NetworksThreads, Shared State, and CoordinationOptimisation and DeploymentAdvanced Patterns. Bestandsnummer des Verkäufers 9789349174115
Anzahl: 2 verfügbar
Anbieter: CitiRetail, Stevenage, Vereinigtes Königreich
Paperback. Zustand: new. Paperback. There's a question that's always been asked by systems programmers working in C++ and those working in Rust. Is there a way to control systems that doesn't mean choosing between power and predictability? Zig represents that path.The idea is pretty clear as really there's no such thing as hidden behaviour. Everything's totally clear about each allocation. Every error is given a name and can be found in the type system. So, every piece of control flow is going to appear at the call site. The programmer always knows what the program does, because the language won't act without instruction. This book teaches Zig through a project-based approach centred on a single growing systems toolkit.This book gives hands-on experience with Zig's allocator model, generic programming through comptime, typed error handling, filesystem and process management, concurrent threads and atomic state, and HTTP server construction, with each concept built on the one before it.For C++ developers, Zig gets rid of undefined behaviour and preprocessor complexity without sacrificing machine-level access. For Rust developers, it's got a simpler ownership model, no borrow checker friction, and a C interoperability path that doesn't need a binding generator. You'll see that both communities have familiar systems programming patterns expressed in Zig that carries none of their respective historical weight.Key FeaturesWrite memory-safe systems code without garbage collector or borrow checker overhead.Control heap allocation using Zig's transparent allocator interface.Build compile-time generic data structures with zero runtime overhead.Handle errors through typed error sets.Interoperate with C libraries directly without binding generators or wrapper layers.Cross-compile production binaries with a single build command.Coordinate concurrent threads safely using Mutex, atomic values, and condition variables.Model data with exhaustive enums and tagged unions.Inspect and manipulate raw memory through typed slices, packed structs, and pointers.Deploy release binaries using Zig's 3 configurable build modes.Table of ContentGetting Started with ZigExploring Zig CodesAllocation, Safety, and Data StructuresGenerics, Reflection, and ToolchainFiles, Processes, and NetworksThreads, Shared State, and CoordinationOptimisation and DeploymentAdvanced Patterns This item is printed on demand. Shipping may be from our UK warehouse or from our Australian or US warehouses, depending on stock availability. Bestandsnummer des Verkäufers 9789349174115
Anzahl: 1 verfügbar
Anbieter: AussieBookSeller, Truganina, VIC, Australien
Paperback. Zustand: new. Paperback. There's a question that's always been asked by systems programmers working in C++ and those working in Rust. Is there a way to control systems that doesn't mean choosing between power and predictability? Zig represents that path.The idea is pretty clear as really there's no such thing as hidden behaviour. Everything's totally clear about each allocation. Every error is given a name and can be found in the type system. So, every piece of control flow is going to appear at the call site. The programmer always knows what the program does, because the language won't act without instruction. This book teaches Zig through a project-based approach centred on a single growing systems toolkit.This book gives hands-on experience with Zig's allocator model, generic programming through comptime, typed error handling, filesystem and process management, concurrent threads and atomic state, and HTTP server construction, with each concept built on the one before it.For C++ developers, Zig gets rid of undefined behaviour and preprocessor complexity without sacrificing machine-level access. For Rust developers, it's got a simpler ownership model, no borrow checker friction, and a C interoperability path that doesn't need a binding generator. You'll see that both communities have familiar systems programming patterns expressed in Zig that carries none of their respective historical weight.Key FeaturesWrite memory-safe systems code without garbage collector or borrow checker overhead.Control heap allocation using Zig's transparent allocator interface.Build compile-time generic data structures with zero runtime overhead.Handle errors through typed error sets.Interoperate with C libraries directly without binding generators or wrapper layers.Cross-compile production binaries with a single build command.Coordinate concurrent threads safely using Mutex, atomic values, and condition variables.Model data with exhaustive enums and tagged unions.Inspect and manipulate raw memory through typed slices, packed structs, and pointers.Deploy release binaries using Zig's 3 configurable build modes.Table of ContentGetting Started with ZigExploring Zig CodesAllocation, Safety, and Data StructuresGenerics, Reflection, and ToolchainFiles, Processes, and NetworksThreads, Shared State, and CoordinationOptimisation and DeploymentAdvanced Patterns This item is printed on demand. Shipping may be from our Sydney, NSW warehouse or from our UK or US warehouse, depending on stock availability. Bestandsnummer des Verkäufers 9789349174115
Anzahl: 1 verfügbar
Anbieter: buchversandmimpf2000, Emtmannsberg, BAYE, Deutschland
Taschenbuch. Zustand: Neu. This item is printed on demand - Print on Demand Titel. Neuware 134 pp. Englisch. Bestandsnummer des Verkäufers 9789349174115
Anzahl: 1 verfügbar
Anbieter: preigu, Osnabrück, Deutschland
Taschenbuch. Zustand: Neu. Learn Zig over Rust and C++ | Learn Modern Systems Programming with Zig for C++ and Rust Developers | Annie Cal | Taschenbuch | Englisch | 2026 | GitforGits | EAN 9789349174115 | Verantwortliche Person für die EU: Libri GmbH, Europaallee 1, 36244 Bad Hersfeld, gpsr[at]libri[dot]de | Anbieter: preigu Print on Demand. Bestandsnummer des Verkäufers 135647028
Anzahl: 5 verfügbar