---
# System prepended metadata

title: Joshua's Recommended Rust Crash Course

---

# Joshua's Recommended Rust Crash Course

## Introductory Reading

### [The Rust Programming Language](https://doc.rust-lang.org/stable/book/)

Also known as "The Book".

* Introductory
* History
* Design
* Excercises

Also available for [purchase](https://www.amazon.com/dp/B071YKRV8Q/ref=cm_sw_em_r_mt_dp_W2PW1VZKY5V53C5F7TC7).

#### Introduction

The Book opens with a quick hands-on project to introduce the basics then explores key concepts in depth, such as ownership, the type system, error handling, and fearless concurrency. Next come detailed explanations of Rust-oriented perspectives on topics like pattern matching, iterators, and smart pointers, with concrete examples and exercises--taking you from theory to practice.
 
The Rust Programming Language will also show you how to:
- Grasp important concepts unique to Rust, like ownership, borrowing, and
  lifetimes
- Use Cargo, Rust’s built-in package manager, to build and maintain your code,
  including downloading and building dependencies
- Effectively use Rust’s zero-cost abstractions and employ your own
 
You’ll learn to develop reliable code that’s speed and memory efficient, while avoiding the infamous and arcane programming pitfalls common at the systems level. When you need to dive down into lower-level control, this guide will show you how without taking on the customary risk of crashes or security holes and without requiring you to learn the fine points of a fickle toolchain.
 
You’ll also learn how to create command line programs, build single- and multithreaded web servers, and much more. 

#### My thoughts

This is where I had started and it has expanded significantly since then. It goes through everything that you would possibly need to know about as well as give you background and history into most of the design and decisions of Rust. Whats important is that it provides excercises for you to do.

It is really key to learn about ownership, borrowing and especially lifetimes. In the beginning you will be tempted to use lifetimes but, it quite required and if you need to use one, perhaps give your design a second thought.

### [The Cargo Book](https://doc.rust-lang.org/cargo/index.html)

* Introductory
* Design
* Excercises

#### Introduction

Cargo is the Rust package manager. Cargo downloads your Rust package's dependencies, compiles your packages, makes distributable packages, and uploads them to crates.io, the Rust community’s package registry. You can contribute to this book on GitHub.

#### My Thoughts

Required reading. 

This is a bit dry reading and also serves as a bit of a reference. You actually can get by without knowing too much about this. However, I do recommend going through the whole of the [Cargo Guide](https://doc.rust-lang.org/cargo/guide/index.html) portion regardless.

You do not need to read the reference materials in Chapter 3 onwards.

### [Programming Rust](https://www.amazon.com/dp/B0979PWD4Z/ref=cm_sw_em_r_mt_dp_HPZ8BP4CG92F0SFZQRVW)

Systems programming provides the foundation for the world's computation. Developing performance-sensitive code requires a programming language that puts programmers in control of how memory, processor time, and other system resources are used. The Rust systems programming language combines that control with a modern type system that catches broad classes of common mistakes, from memory management errors to interthread data races.

With this practical guide, experienced systems programmers will learn how to successfully bridge the gap between performance and safety using Rust. Jim Blandy, Jason Orendorff, and Leonora Tindall demonstrate how Rust's features put programmers in control over memory consumption and processor use by combining predictable performance with memory safety and trustworthy concurrency.

You'll learn:

* Rust's fundamental data types and the core concepts of ownership and borrowing 
* Language basics including error handling, crates and modules, structs, and enums
* How to write flexible, efficient code with traits and generics
* Rust's key power tools: closures, iterators, and asynchronous programming
* Collections, strings and text, input and output, concurrency, macros, unsafe code, and interfacing with foreign functions

#### My Thoughts

This guide was created to essentially fill the gap that others that got started with Rust felt like was missing when they got started. The Rust Programming Language book is quite high level and doesn't really do any deep dives. This does. It also has a bunch of other concepts that the other materials do not touch on.

Unforunately, it doesn't get into "nomicon" territory, but that should be ok. You do not want to get into that really, which a lot of developers tend to agree with. A lot of developers really dislike unsafe code outside of FFI.

Absolutely required reading. Its updated just as much as Rust updates so be sure to get the Kindle version or another edition that is in PDF format or such. It is a little bit pricey though. I think we can expense it Arto?

## Reference Material

### [The Rust Reference](https://doc.rust-lang.org/reference/index.html)

* Reference
* Patterns

#### Introduction

This book is the primary reference for the Rust programming language. It provides three kinds of material:

* Chapters that informally describe each language construct and their use.
* Chapters that informally describe the memory model, concurrency model, runtime services, linkage model, and debugging facilities.
* Appendix chapters providing rationale and references to languages that influenced the design.

#### My Notes

Great introductory explaining every construct.

If you are not sure how to do something in Rust that you know how to do or are familiar with a concept, use this to help you accomplish what you need to do. It is loaded with valuable concepts and patterns.

### [The Cargo Reference](https://doc.rust-lang.org/cargo/reference/index.html)

* Reference

#### Introduction

The reference covers the details of various areas of Cargo.

#### My Notes

The [manifest format](https://doc.rust-lang.org/cargo/reference/manifest.html) is notable reading. Knowing how to make [build scripts](https://doc.rust-lang.org/cargo/reference/build-scripts.html) is fantastic too.
