Learn Rust Programming

288 Pages·2022·7.455 MB·English

by  Claus Matzinger

Learn
Rust Programming
Safe Code, Supports Low Level and
Embedded
Systems Programming with a Strong
Ecosystem
Claus Matzinger
www.bpbonline.com
Copyright © 2022 BPB Online
All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or
transmitted in any form or by any means, without the prior written permission of the publisher,
except in the case of brief quotations embedded in critical articles or reviews.
Every effort has been made in the preparation of this book to ensure the accuracy of the information
presented. However, the information contained in this book is sold without warranty, either express
or implied. Neither the author, nor BPB Online or its dealers and distributors, will be held liable for
any damages caused or alleged to have been caused directly or indirectly by this book.
BPB Online has endeavored to provide trademark information about all of the companies and
products mentioned in this book by the appropriate use of capitals. However, BPB Online cannot
guarantee the accuracy of this information.
Group Product Manager: Marianne Conor
Publishing Product Manager: Eva Brawn
Senior Editor: Connell
Content Development Editor: Melissa Monroe
Technical Editor: Anne Stokes
Copy Editor: Joe Austin
Language Support Editor: Justin Baldwin
Project Coordinator: Tyler Horan
Proofreader: Khloe Styles
Indexer: V. Krishnamurthy
Production Designer: Malcolm D'Souza
Marketing Coordinator: Kristen Kramer
First published: July 2022
Published by BPB Online
WeWork, 119 Marylebone Road
London NW1 5PU
UK | UAE | INDIA | SINGAPORE
ISBN 978-93-55511-546
www.bpbonline.com
Dedicated to
My wife and my daughter.
About the Author
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 Microsoft’s 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 customer’s
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.
Acknowledgement
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 I’d 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, it’s 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.
Preface
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 Apple’s 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 Rust’s 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, let’s look at what each chapter contains:
Chapter 1 provides you with the basics of the Rust programming language.
To set the stage appropriately, you’ll learn about byte code, compilers and
compilation, simple types, and variables.
Chapter 2 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 won’t pose
much of a challenge for you any longer.
Chapter 3 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).
Chapter 4 ventures further into the depths of Rust’s 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.
Chapter 5 gets to the heart of Rust’s 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.
Chapter 6 introduces the Rust standard library collections, which will play
an important role in any Rust programming career. This includes the Vector,
HashMap, HashSet, their BTree counterparts, and the Iterator trait which
allows to traverse these collections.
Chapter 7 covers working with input and output of various sorts, utilizing
the Read and Write traits of the Rust standard library, as well as interacting
with the outside world with command line arguments, Files and
environment variables. Afterwards your programs can easily interact with
the environment.
Chapter 8 gets into how to add third party dependencies from the crates.io
package repository. Additionally, the chapter covers custom build processes
and custom cargo commands.
Chapter 9 provides details on testing your Rust code, including unit tests,
integration tests, and benchmarking. Once you know this, there is no excuse
not to test your code!
Chapter 10 adds documentation to your Rust repository. This means that
you can generate websites from your code comments and even test the
examples. After testing, this is Rust’s way of making documenting code
convenient.
Chapter 11 starts the advanced part of the book by introducing macros.
These code constructs allow to generate code and insert it right before the
final steps of compilation. Next to using macros, you’ll learn how to create
the different kinds supported in Rust as well.
Chapter 12 dives deep into heap memory allocation and the types Rust
provides for managing it. Together with borrowing and ownership concepts,
this chapter explores reference counters, boxes, memory layouts, and the
interior mutability pattern.
Chapter 13 is all about concurrency using threads, locks, and
synchronization. Thanks to borrowing and ownership principles, this is
significantly less error-prone than in other languages.
Chapter 14 expands on concurrency by explaining async, short for
asynchronous programming. The chapter includes using the provided
syntax elements async and await and how to use Futures to schedule tasks
on an I/O loop.
Chapter 15 introduces the topic of generics. Generics are a way to provide
implementations on functions without relying on specific types, instead
using traits. This is complemented by a deeper dive on lifetimes, since those
may differ between the generic types.
Chapter 16 concludes the book with an overview over unsafe and the
foreign function interface (FFI). These language constructs allow you to
integrate with other programs, the operating system, or other programming
languages by linking libraries to Rust or creating linkable libraries from
Rust. You’ll also learn about the dark arts of writing unsafe code that the
compiler is less strict about…