Rust Under the Hood: A deep dive into Rust internals and generated assembly

I'm a software engineer who writes Rust code for professional and personal projects. When working with latency-sensitive code that has to be executed within microseconds, every CPU instruction matters. Therefore, it is crucial to develop an intuition of how optimized (or unoptimized) your Rust code is. To hone the intuition, you'd need to develop a deep understanding of the x86 assembly code generated by the Rust compiler (i.e., Rust internals). This book offers exactly that.While compiler tools like Godbolt allow you to examine generated assembly, comprehending it can be challenging without prior experience in x86 assembly. This book addresses that gap, guiding readers with little to no assembly background through Rust internals. The pedagogical format of this book is excellent. It uses a well-structured approach, building knowledge gradually with each chapter. It leverages pictorial diagrams (e.g., flow charts and sequence diagrams) crafted in painstaking detail to elucidate complex concepts. For each assembly code snippet, it has thorough annotations in the form of code comments alongside the assembly code. Each chapter concludes with key takeaways, summarizing the main points, and the final chapter's comprehensive key insights alone is worth the book's price.That said, you don't need to be working on latency-sensitive projects to benefit from this book. Concepts like tail calls, closures and async/await are commonplace in other programming languages and this book has dedicated chapters explaining the inner workings of these programming concepts from the Rust perspective. As a software engineer, deepening your understanding of the tools of your trade is always beneficial. The in-depth knowledge of Rust internals provided by this book can also improve your proficiency in other programming languages, making you a more effective software engineer.

I am a begineer in rust and had recently started reading this book. Every chapter focuses on the fundamentals of programming language for rust and shares the aspects of performance at assembly level through multiple code experiments. It provides a good arena for hands on experience if readers want to dig deeper. The book is very easy to follow and is structured very well. It does indeed cover under the hood aspects for rust and given my experience, I'd call it a must read for be it a beginner or expert in rust. Especially for me, reading this book helped me onboard to using rust very quick. This helped me be a better programmer for sure. If anyhone is looking for a well structured, easy to follow book to learn more about rust, I'd highly recommend this book. Thanks for writing this book.

This book suffers greatly from the design and typography. The flowcharts serve no purpose other than wasting the paper since the given assembly code has extensive comments and rarely has complex flows which might require a visual aid. The symbols for load/store/etc operations are very hard to differentiate visually and not very helpful.Also the book feels like just a collection of assembly output for different pieces of the language, rather than having a coherent direction or a deeper investigation below the compiler output.

I'm one of the technical reviewers of this book. The reason I agreed to review this book is because I spent quite a bit of time using Godbolt to resolve discussions about the generated assembly of C++ in game programs. I haven't had to do this for Rust, but I was curious as to how the features of Rust were translated to x64 assembly. This book is a plainly written and concise guide to the efficient assembly code generated by Rust for much of the language: from the basics like enums, structs, and arrays to more advanced concepts including iterators, closures, tail-call optimizations, and async/await. There are many detailed explanations and insights provided for both the Rust and assembly code that include numerous flowcharts. This book, or at least parts of it, would make an excellent addition to a computer architecture class so that the section on assembly would be far more concrete.