Rust Essentials: Fundamentals of Rust Programming

Introduction

The book "Rust Essentials" by Ivo Balbaert (published in 2017, 294 pages) is a practical introduction to the Rust programming language, which is rapidly gaining popularity due to its safety, performance, and modern capabilities. At the time of its release, the book was one of the few structured guides to Rust aimed at developers already familiar with other languages (C, C++, Python, Java).

In this review, we will break down what the book is, who it is written for, what topics it covers, and whether it is worth reading today, when the Rust ecosystem has grown significantly.

What the book is about

"Rust Essentials" is not a reference book or an academic textbook. It is a practical guide that step by step introduces the reader to the core concepts of Rust: ownership, borrowing, lifetimes, the type system, traits, error handling, memory management, multithreading, and interaction with C code. The book is built around small projects and code examples that can be immediately run and modified.

The author starts with installing tools and setting up the environment, then moves on to syntax, memory management, data structures, functions, modules, and testing. Separate chapters are dedicated to working with external libraries (crates), creating web applications in Rust (using the Iron framework, which was popular at the time of writing), and interacting with C via FFI (Foreign Function Interface).

Who this book is for

The book is aimed at programmers who already have experience with other languages (C, C++, Python, Java, C#). If you have never programmed before, "Rust Essentials" may seem difficult, as the author does not explain basic concepts like loops, arrays, or functions — it is assumed the reader is familiar with them. However, for those who want to quickly get into Rust, the book will be an excellent starting point.

What the reader will learn

• Basics of Rust syntax: variables, data types, control structures, functions.
• The ownership and borrowing system: how Rust guarantees memory safety without a garbage collector.
• Lifetimes: how the compiler checks the correctness of references.
• Traits and generic programming: creating polymorphic code.
• Error handling: using Result, Option, panic!, and the "unwrap or expect" pattern.
• Working with collections: vectors, strings, hash maps.
• Modules and code organization: how to structure projects.
• Testing: unit tests, integration tests, documentation tests.
• Multithreading and concurrency: threads, channels, mutexes, Arc.
• Interfacing with C: calling C functions from Rust and vice versa.
• Creating web applications: a simple HTTP server on Iron.

Strengths of the book

Practical focus. Each chapter contains code examples that can be copied and run. The author does not get carried away with theory but immediately shows how to apply concepts in practice.

Good structure. The book logically progresses from simple to complex. After studying the basics, the reader is ready for more advanced topics such as multithreading and FFI.

Accessible language. Ivo Balbaert writes clearly, without excessive academicism. Complex concepts (e.g., lifetimes) are explained with concrete examples, which makes understanding easier.

Emphasis on safety. The book constantly reminds about the Rust philosophy: safety without sacrificing performance. This helps the reader immediately get used to the correct programming style.

Projects at the end of chapters.