Step Ahead with Rust

Introduction

The book "Step Ahead with Rust" (author — Jonathan Creekmore, 2017, 222 pages) is a compact but rich practical guide to the Rust programming language. Unlike many introductory textbooks, this book does not waste time explaining basic programming concepts — it assumes the reader is already familiar with other languages (C, C++, Python, Java) and wants to quickly master Rust's specifics: the ownership system, borrowing, lifetimes, safe memory management, and concurrency without data races.

The book was published in 2017, when Rust was just beginning to gain popularity, and it remains relevant for those who want to understand the "spirit" of the language, rather than just learn the syntax. It does not claim to be an encyclopedia — it is more of an intensive course for those who want to take a step forward in their professional development.

What the book is about

"Step Ahead with Rust" consists of 12 chapters, each dedicated to a key topic of the language. The author consistently guides the reader from setting up the environment to creating multithreaded applications and working with FFI (Foreign Function Interface).

Main topics of the book:

• Ownership and borrowing system — the fundamental concept of Rust that ensures memory safety without a garbage collector. The author details how the compiler checks code correctness.
• Types and traits — generic programming, polymorphism, implementing standard traits.
• Memory management — stack, heap, smart pointers (Box, Rc, Arc, RefCell).
• Error handling — Result, Option, unwrap, the ? operator, custom error types.
• Parallelism and concurrency — threads, channels, mutexes, Send and Sync.
• Macros — declarative and procedural macros, their application.
• FFI and interaction with C — calling C functions from Rust and vice versa.
• Testing and documentation — unit tests, integration tests, built-in documentation.

Each chapter contains small code examples that can be run immediately, and exercises to reinforce the material.

Who this book is for

The book is aimed at experienced developers who already have experience with type systems, pointers, memory (C, C++) or with strongly typed languages (Java, C#). It will seem difficult for programming beginners, as the author does not explain what a loop, function, or array is — he immediately moves on to Rust's features.

The ideal reader is a programmer who wants to:

• understand why Rust is considered both safe and fast;
• learn to write code that does not crash with a segmentation fault;
• master the ownership system, which seems intimidating at first glance;
• try Rust for systems programming, embedded systems, or high-load services.

What the reader will learn

After reading the book, the reader will be able to:

• Confidently use ownership, borrowing, and lifetimes — explain why the compiler rejects certain code.
• Work with smart pointers and understand when to use which one.
• Write safe concurrent code without data races, using channels and mutexes.
• Create macros to reduce repetitive code.
• Integrate Rust with existing C libraries via FFI.
• Cover code with tests and generate documentation.
• Understand Rust's internal workings: how trait resolution, monomorphization, and dispatch work.

Strengths of the book

• Conciseness and focus — only 222 pages, but no fluff. Each chapter is a concentrate of useful information.