Rust

Advanced Rust Programming goes beneath Rust’s safe surface to reveal the machinery that makes high-performance systems possible. Explore unsafe contracts, atomics, async internals, FFI, allocators and more through practical examples that sharpen your instincts and help you build faster, safer production-grade software.

Discover how to make Python data processing faster, leaner and ready to scale with Polars. Starting with the basics, this practical guide takes you all the way to production-grade pipelines for massive datasets, with clear explanations of how Polars works, why it is fast and how to get the best performance from it.

In this book, we are building a complete working server, and again we rebuild the whole thing on a different framework. It's about testing out a new approach. If the architecture is honest, the second version costs almost nothing and the business logic never moves. We ran the test, and I let you watch the result rather than describing it.

Go from your first line of Rust to building fast, safe, and production-ready applications with confidence. This practical guide explains every essential language feature, modern development tools, and key ecosystem crates through clear explanations and real-world examples, helping you write idiomatic, efficient and maintainable Rust code from day one.

The Rust book written for Python developers. Every concept explained from your Python mental model — ownership through GC comparison, traits through protocols, concurrency through the GIL. Build a CLI tool that outperforms Python by 10-50x, then call it from Python with PyO3.

Cleiton Augusto Correa Bezerra is a systems analyst and software engineer from Brazil at the intersection of quantum computing and high-performance Rust. He created CleitonForge and authored the Quant

Cleiton Augusto Correa Bezerra is a systems analyst from Brazil, creator of CleitonForge and author of the Quantum Gate Convention Standard (QGCS). His HOG Blindness theorem proved that quantum volume benchmarks are algebraically blind to Rz sign inversions — a class of silent bugs affecting production quantum backends.

The latest version of Rust (1.85) has some great new features, like async closures, more stable associated function return types, and const generics that are now mature enough to underpin serious numerical libraries. The linfa and smartcore ecosystems have developed into decent classical machine learning stacks. The Burn training framework feels native to Rust, not like it's been ported from it. The Candle makes it so that loading pre-trained transformer models is more of an engineering task than a research exercise. The crates that used to need all sorts of workarounds now just work.

I wrote this book to show exactly what happens when you add Rust to the kernel. Not as a toy. Not as a single driver in a conference demo. It's a full module that covers process management, memory allocation, file systems, networking, device drivers, inter-process communication, and even machine learning inference. It's all built on safe abstractions, all compiled into one loadable binary, all tested on a running kernel. You'll find that each chapter adds new source files to the same module.

This book is basically a record of my serious learning journey with Zig. The application at its heart, Zigkit, started as a single print statement and ended as twenty-five cooperating modules handling everything from arithmetic to HTTP. It's small enough to understand completely and complete enough to demonstrate every major systems programming concern. Each section of the book adds one module, introduces one concept, and produces one working program.

Take everything you know about Ruby — classes, modules, exceptions, enumerable methods — and translate it directly to Rust. No fluff, no abstract theory, just runnable Ruby-to-Rust comparisons with hands-on exercises.

Most blockchain books teach the theory. This one walks you through building a complete Bitcoin-style blockchain in Rust, end to end — cryptography, consensus, networking, persistence, REST API, desktop wallets, and Kubernetes deployment.

Language models guess. Knowledge graphs know. Rusty Graph shows you how to build a local AI agent whose memory is a real knowledge graph — typed, validated, reasoned over, and queryable with SPARQL — all inside a single static Rust binary. No JVM. No Docker sidecar. No Python runtime bolted to the side. You will build Ares a research-assistant agent that observes papers, forms beliefs, makes promises to other agents, and tracks the provenance of every fact it holds. Chapter by chapter, Ares grows from an empty Cargo workspace into a full pipeline: > load → reason → validate → query → answer All of it in under a thousand lines of idiomatic Rust, using three crates that actually work today: `oxigraph`, `reasonable`, and `rudof_lib`. `grapfeo` You will learn how to- Model a domain as RDF triples and load them into an embedded store. - Write RDFS and OWL 2 RL axioms that infer trust, identity, and inverse relationships — automatically. - Guard your graph with SHACL shapes that reject bad data at the boundary, not in production. - Query everything with SPARQL, from simple lookups to federated queries across named graphs. - Wire the graph into a hybrid RAG pipeline so your LLM answers are grounded in facts, not vibes. Who it is forRust developers building agents, assistants, or any system where the answer "the model said so" is not good enough. You should be comfortable with Cargo and traits. You do **not** need any prior semantic-web background — every concept is introduced through Ares before any formal definition appears. Why Rust, why nowLocal agents are the next deployment target: a user's laptop, a Raspberry Pi, a WASM sandbox. Python cannot go there comfortably. Rust can. This book is the missing manual for the Rust side of the semantic web — the one that tells you exactly which crates work, where the ecosystem is thin, and how to ship anyway. Stop hoping your model tells the truth. Give it a graph that does.