Vitaly Reads: #5, February 2026

The Rust Programming Handbook: An end-to-end guide to mastering Rust fundamentals, Francesco Ciulla

Last week, on my way to RustNation in London, I finally had the rare luxury everyone secretly dreams about: uninterrupted reading time. I used it well — with The Rust Programming Handbook: An End-to-End Guide to Mastering Rust Fundamentals by Francesco Ciulla.

I first met Francesco about half a year ago at RustConf in Seattle. Since then, I feel like I hear something new from him almost every single week — a talk, a video, a post, a course. His consistency in producing high-quality Rust content honestly amazes me. This book feels like a natural extension of that energy.

The teaching method: layered and deliberate

What I liked most is the layered approach. A concept appears for the first time — simple example, short overview, just enough to “set the stage.”

Then it appears again — more details.

Then a third time — deeper, more nuanced, more Rusty.

This is exactly how you teach Rust. You don’t dump lifetimes, ownership rules, and trait objects on someone in a single shot. You prepare them. You let their brain build the right mental compartments.

And the assignments — folks, do the assignments while reading books. They are there for a reason. Francesco’s exercises are efficient and purposeful. Same for the questions sprinkled throughout the chapters: they’re great for a quick sanity check — “did I really understand what I just read?”

Explanations that actually work

Some Rust topics are notoriously hard to explain:

• move vs copy vs clone

• ownership and borrowing

• lifetimes

• the orphan rule

• trait objects

This book does a very good job here. Especially ownership and borrowing — the visualizations are simple yet effective. Not overengineered diagrams, not abstract theory — just the right level of clarity.

Lifetimes receive surprisingly solid coverage for a beginner book. Error handling too — including thiserror and anyhow. Smart pointers are not hand-waved away. Testing gets proper attention (kudos for introducing TDD, and discussing mocks and stubs!). Logging is there. Resource management best practices are there.

This is not just “hello world” Rust.

Who this book is really for

This is important.

This is a book for beginners with Python or JavaScript background — not C or C++. And that’s exactly what we need today. The majority of new Rustaceans are not coming from systems programming. They’re coming from high-level ecosystems.

Francesco writes with that audience in mind.

And it shows.

Not just theory — real practice

The book doesn’t stop at language fundamentals. It moves into:

• Web development (with databases!)

• Configuring via .env files

• Dockerizing Rust applications

• Networking — all the way down to TLS

• WebAssembly (my love ❤️)

• Even a glimpse into kernel modules (oh my goodness, this is so good)

This is what makes it a handbook, not just an introduction.

Each chapter builds practical examples on top of the concepts just covered. You don’t learn features in isolation — you see them used immediately.

Coffee, pizza, and carbonara

Many examples revolve around espresso, moka, and other coffee beverages — “software for a classic Italian coffee bar.” There’s pizza, carbonara, and plenty of Italian food references.

You always know you’re reading a book written by an Italian 🙂

It adds personality without becoming distracting.

There are occasional jokes (not too many!). I especially liked the one about the crowded legal disclaimer in function signatures.

My small complaint

There are two chapters: one on OOP and one on functional programming. I understand why they are there. Readers expect them. Publishers expect them.

But here’s my take: Rust is not about OOP or functional style. It’s about Rust style. We use the most appropriate Rust feature when we need it. Labeling things as “this is OOP” or “this is functional” is unnecessary baggage.

I would much rather see discussion framed around software design patterns — observers, builders, strategies, iterators — without caring about their historical origins. Future developers don’t need a taxonomy of paradigms. They need tools.

And trying to make Rust code look like “real OOP” code? That should be prohibited. (Yes, I’m looking at the section about simulating inheritance patterns.) Rust does not need to pretend to be something else.

What’s missing?

Async programming coverage is relatively light. That’s a bit sad — but understandable. The book is already 700+ pages. At some point, you have to stop.

Hidden gems

The chapter summaries are excellent.

If you are not a beginner, start with them. I’m serious. Read the summary first — I guarantee you’ll quickly notice something you didn’t know or haven’t thought about in a while. Then you’ll dive into the chapter anyway.

I also appreciated the section on debugging techniques, including customizing debug output. Small things like that matter in real life.

Throughout the book, best practices are consistently emphasized — either for readability, maintainability, efficiency, or safety. That’s the right goal.

Final verdict

I love this book.

I genuinely recommend it as a first Rust book for beginners — especially those coming from Python or JavaScript backgrounds.

It’s structured, practical, opinionated (in a good way), and deep where it needs to be. It respects the reader’s intelligence. It doesn’t oversimplify. And it doesn’t romanticize Rust either — it teaches it.

If you’re starting your Rust journey — this is a very solid place to begin.