Claus Matzinger - Learn Rust Programming: Safe Code, Supports Low Level and Embedded Systems Programming with a Strong Ecosystem

My wife and my daughter.

Claus Matzinger: In the last 10 years as a Software Engineer I have worked with many programming languages, but Rust stood out from the beginning. With its unique approaches to some of the most challenging issues when developing large-scale applications.

After getting to know the language in its infancy, I spoke at and hosted several Rust Meetups (in Munich, Berlin, Linz, ), joined the official Community team, connected Microsofts security engineers with the Rust core team, and wrote several books and courses on Rust.

Today, I am a senior engineer working on a major Rust code base in FinTech, covering everything from no_std code, to different CPU architectures, and soon WebAssembly. In the past, I have created games for improving mental health, helped build a distributed SQL database at a startup, maintained a Smalltalk application, and worked on customers business critical enterprise systems at Microsoft.

As a quickly evolving language that is deeply technical in nature, Rust has a daunting learning curve, that I love to help new and experienced programmers overcome. For that, I also blog regularly about practical things to do with Rust at https://blog.x5ff.xyz.

Creating something as fundamental as a programming language is a major undertaking by many people and it would require another book to honor each contribution. However Id like to thank all contributors to the Rust programming language for creating such a great language - it has become more than a tool for me and many others. With this book I want to pay it forward by instilling this passion in others.

In these early days of Rust, its not common to work with my favorite programming language on a daily basis. Thanks to the team at DEX Labs I get to tinker and work in an exciting environment that takes Rust from the lowest levels of CPUs to WebAssembly - I truly enjoy every minute of that.

Rust is still a young language and throughout its formative years it has passed through many stages. Before Rust 1.0 was released, the language had already tried different paradigms for memory management and even types. However, leaving those initial ideas behind made the language what it is today: a really fast and safe language with a quirky memory management technique and an opinionated compiler.

While it comes with a steep learning curve, the ideas have spread and other programming languages (for example Apples Swift) picked some parts up quickly, resulting in an overall improvement for programmers and software engineers. I am convinced that by learning Rust, you learn more about programming as well and become better for it.

In many ways, the system of borrowing and ownership of memory keeps the questions Where does this come from? and Where does this go? always at the forefront of your programming mind. Even while writing JavaScript, a much more permissible language, you will become aware of where your objects are and where they should be, as well as whether or not you should create a copy. Personally, I think that alone is worth learning more Rust.

To start your journey, this book provides 16 chapters in increasing difficulty. Starting with the basics, you will quickly advance towards fundamentals of the standard library, memory management, and end with highly advanced features such as Rusts unsafe features. Each chapter comes with a challenge in the end so you can experiment with what you learned.

After completing this book, you will have built your own LinkedList data structure and several other small programs from along the way. Before we start off, lets look at what each chapter contains:

provides you with the basics of the Rust programming language. To set the stage appropriately, youll learn about byte code, compilers and compilation, simple types, and variables.

goes a little deeper into program flow and controlling it. This is where you see decision making with if, as well as while and for loops introduced. Afterwards, reading short code examples in Rust wont pose much of a challenge for you any longer.

covers the heart of how Rust stores data in memory. This chapter is all about creating data structures (structs), modules, and functions. For your programming journey, that means you can now store data and attach behavior (do stuff with it).

ventures further into the depths of Rusts type system by exploring enumerations (enums), traits, and pattern matching. These constructs allow for more efficient decision making based on type variants and share behavior between types using traits.

gets to the heart of Rusts memory management system: borrowing and ownership. The chapter details sharing data structures between functions, how to add mutability, and introduces the notion of scopes. This chapter concludes the fundamentals of the programming language, so afterwards you can solve basic and intermediate problems using Rust.