• Rust Language Cheat Sheet: Complete, interactive cheat sheet.
• Writing A Wasm Runtime in Rust: A guide to write a wasm runtime in rust.
• Rust and WebAssembly: This small book describes how to use Rust and WebAssembly together.
• Rust Design Pattern: Idioms, patterns, and anti-patterns for Rust.
• Effective Rust: 35 specific ways to improve your Rust code.
• PingCap Talent Plan Courses: Open source training courses about distributed database and distributed systems.
• Learning Material for Idiomatic Rust: Here’s a curated list of resources to help you write ergonomic and idiomatic Rust code.
• Stacked Borrows Implemented
• Rust: A unique perspective
• Blazingly Fast Linked Lists
• Rust lang Tips and Tricks
• rust-tips-and-tricks
• Rust Atomics and Locks
• Learn Rust the Dangerous Way
• Learning Rust: Bare Threading
• Write Cleaner, More Maintainable Rust Code with PhantomData
• Hexceptional Encoding: Mastering the Art of Hex Conversion in Rust
• The Absolute Minimum Every Software Developer Must Know About Unicode in 2023 (Still No Excuses!)

Specialized Topics:

• Error Handling in Rust: Rust has an error handling mechanism that may be unfamiliar to you if you have a C/C++/C# background. Andrew Gallant’s blog post on the subject is a great overview: https://blog.burntsushi.net/rust-error-handling/
• Web Assembly: Rust has a great Web Assembly story. Learn more here: https://rustwasm.github.io/book/
• Embedded Programming: Rust allows you to replace C in your embedded work flows. https://docs.rust-embedded.org/book/

Libraries to Know

• Tokio - async programming engine: https://github.com/tokio-rs/tokio
• Serde - Serialization/Deserialization library: https://github.com/serde-rs/serde
• Bitflags - Structs that are just a series of bits: https://github.com/bitflags/bitflags
• Rand - random number generation: https://github.com/rust-random/rand
• Regex - regular expressions: https://github.com/rust-lang/regex
• winapi - bindings for windows APIs https://github.com/retep998/winapi-rs

Want to know more?

As I said at the start, this is just a quick introduction and glosses over many details. The exact rules about unique and shared access in Rust are still being worked out. The Aliasing chapter of the Rustonomicon explains more, and Ralf Jung’s Stacked Borrows model is the start of a more complete and formal definition of the rules.

If you want to know more about how shared mutability can lead to memory-unsafety, read The Problem With Single-threaded Shared Mutability by Manish Goregaokar.

The Swift language has an approach to memory safety that is similar in some ways, though its exact mechanisms are different. You might be interested in its recently-introduced Exclusivity Enforcement feature, and the Ownership Manifesto that originally described its design and rationale.