I learn Rust by reading The Rust Programming Language (aka. TRPL) book.

This is my mind map and collection of resources for learning Rust in early 2019.

I plan to continuously update this list if time allows in future. I will move this into its own GitHub repo or something more permanent when this grow.

My notes while working through TRPL.

Programming paradigm: functional, imperative, structured, generic, concurrent

Rust focus: type and memory safety, precision, concurrency, performance, reliability

Rust enforces memory safety. Compile time memory safety guarantees protects us from:

• Uninitialized variables
• Use-after-free (UAV)
• Double-frees
• Exception due to NULL pointers (Rust does not have NULL)
• Impossible to forget to lock the mutex
• Data races between threads
• Mostly no memory leaks
• Iterator invalidation

In the safe subset of Rust, there's no undefined behavior at runtime:

• Integer overflow is defined
• Array access is bounds checked

Rust is modern — built with the experience learned in the past 40 years of programming languages.

Modern language features:

• Generics
• Enums and pattern matching
• No overhead FFI

Modern tooling:

• Great compiler errors
• Built-in dependency manager
• Built-in support for testing

• Users forum - official forum
• Internals forum - official forum
• The #beginners channel on Discord

• Get started with Rust - Official learning resources.
• Rust Cookbook - A collection of simple examples that demonstrate good practices to accomplish common programming tasks, using the crates of the Rust ecosystem.
• Rust by Example - A collection of runnable examples that illustrate various Rust concepts and standard libraries.
• Learn Rust With Entirely Too Many Linked Lists
• https://github.com/rust-lang/rustlings - Small exercises to get you used to reading and writing Rust code!
• Tour of Rust - A step by step guide through the features of the Rust programming language.
• A half-hour to learn Rust - 'similar' style to "Learn X in Y Minutes". It covers variable bindings, pattern matching, immutability, references, lifetimes, borrow rules, structs, traits, enums, generics, closures, and more.
• Read Rust: Getting Started - Introductory posts, guides and tutorials for getting started with Rust.
• Learning Rust - Rust programming language tutorials.
• Rust-101 - A tutorial for the Rust language.
• https://github.com/learning-rust/site - Rust Programming Language Tutorials for Everyone!
• Comprehensive Rust 🦀 - This is the Rust course used by the Android team at Google. It provides you the material to quickly teach Rust to everyone. The course covers the full spectrum of Rust, from basic syntax to advanced topics like generics and error handling. It also includes Android-specific content on the last day.

Rust stream on YouTube and/or Twitch:

• Jon Gjengset's stream on Rust - I first discovered Jon's stream while looking at Noria data-flow for high-performance web apps. Jon's stream covers mostly advanced concepts in Rust but not until recently (2020) where he started to covers more "advanced beginners" stuffs.
• Ryan Levick's "advanced beginners" stream on Rust who are familiar with the concepts of ownership, closures and threads but don't yet have a firm grip on them.
• Visualizing memory layout of Rust's data types
• Intorust screencasts by Niko Matsakis.

• Rust for Rustaceans by Jon Gjengset - a book that covers the next steps of Rust after TRPL/"the book". The book is written for people who are already familiar with Rust. The idea is that you read The Rust Programming Language (TRPL) first, play around with Rust for a bit on your own, maybe start using it "for real", and then pick this up to hone your skills. It is fairly fast paced, but is still has a good amount of low level details. (TLDR; if you're comfortable in Rust, this book is the next step up for intermediate developers.)
• Rust in Action by Tim McNamara - Systems programming concepts and techniques.
  • Book launch announcement
• Programming Rust by Jim Blandy, Jason Orendorff, Leonora F. S. Tindall - This revised, second edition covers the Rust 2021 Edition. It expands on many concepts in TRPL book. I like that it explains the memory layout of common Rust data structures.
• The Rustonomicon book - Meet Safe and Unsafe.
• https://github.com/psibi/rust-book-summary - Summary of the Rust book.

• Rust: A Language for the Next Forty Years by Carol Nichols - A talk about Rust's safety and stability. And a little bit about railroads.
• Learning systems programming with Rust - Closing keynote at the first RustConf 2016 by Julia Evans.

• https://cheats.rs/

Useful libraies. Some created by Rust core members.

Blessed - An unofficial guide to the Rust ecosystem.

Not-Yet-Awesome Rust - A curated list of Rust code and resources that do NOT exist yet, but would be beneficial to the Rust community.

• https://github.com/rayon-rs/rayon
• https://github.com/brson/stdx

• https://github.com/xi-editor/xi-editor - an example of real-world usage of Rust.
• Real Time For the Masses (RTFM) framework for ARM Cortex-M microcontrollers

Cross-platform, desktop UI:

• https://github.com/anp/moxie
• https://github.com/KenSuenobu/rust-pushrod
• https://github.com/tauri-apps/tauri
• https://github.com/hecrj/iced

• https://medium.com/@cevans3326/rust-in-2018-lets-fix-where-the-bullet-holes-aren-t-7e94cea0bd53

• Read Rust collects interesting posts related to the Rust programming language.

  Note-to-self: I found the writer through Mastodon

• Official Posts:

  • https://blog.rust-lang.org/2016/12/22/Rust-1.14.html
  • https://blog.rust-lang.org/2017/05/15/rust-at-two-years.html
  • https://blog.rust-lang.org/2017/05/05/libz-blitz.html
  • https://blog.rust-lang.org/2016/05/16/rust-at-one-year.html
  • https://blog.rust-lang.org/2016/06/30/State-of-Rust-Survey-2016.html

Blogs

• Manish Goregaokar's blog
• Mara's blog
• Steve Klabnik's blog
• Amos's blog
• Yoshua Wuyts's blog
• Llogiq's blog
• Raph Levien’s blog
• Sean McArthur's blog

• This Week in Rust

• https://github.com/rustasync/areweasyncyet.rs - A website for tracking development progress of async/await syntax of Rust programming language in the language itself as well as its ecosystem.

https://areweideyet.com/

Things I discovered:

• https://github.com/racer-rust/racer - Rust code completion utility.
• explaine.rs - An interactive playground to explore the syntax of the Rust code.

Status: https://www.arewewebyet.org/

• https://brandur.org/rust-web
• https://larder.io/blog/larder-links-09-rust-web-frameworks/
• https://github.com/iron/iron
• https://github.com/nickel-org/nickel.rs
• https://github.com/tokio-rs/tokio-minihttp
• https://github.com/trezm/Thruster
• https://github.com/graphql-rust/juniper
• Tower-Web and Warp joint effort
  • Warp on Zeit Now or AWS Lambda: https://zeit.co/blog/introducing-now-rust
• Templates
  • https://github.com/djc/askama

• Actix-web 1.0 – A small, pragmatic, and fast web framework for Rust
• https://www.reddit.com/r/rust/comments/cbn1no/rust_is_leading_most_of_the_techempower_web/
• TechEmpower/FrameworkBenchmarks#4834
• 1.0 summary: https://www.reddit.com/r/rust/comments/bwy99w/actixweb_10_released/eq2t499/
• https://www.reddit.com/r/programming/comments/cbgv6f/rust_async_frameworks_dominate_techempower/
• https://www.reddit.com/r/rust/comments/axy0hp/patterns_to_scale_actixweb_and_diesel/
• https://www.reddit.com/r/rust/comments/ce09id/why_we_need_alternatives_to_actix/
• https://64.github.io/actix/
• Examples:
  • https://github.com/flofriday/thumbcloud
  • https://github.com/ArtRand/kafka-actix-example
  • https://medium.com/meetbitfury/generic-methods-in-rust-how-exonum-shifted-from-iron-to-actix-web-7a2752171388
  • https://blog.approveapi.com/tutorials/rust-actix-web-approveapi-magic-login-link/
• https://render.com/docs/deploy-actix-todo

Actor Model

• https://simplabs.com/blog/2018/06/11/actix/

• https://github.com/flosse/rust-web-framework-comparison#server-frameworks

Rust bindings for native Node.js modules:

• https://github.com/neon-bindings/neon

• https://www.reddit.com/r/rust/comments/azit15/i_made_a_super_simple_example_guide_of_how_to/
• https://www.reddit.com/r/rust/comments/abfoe0/my_experience_converting_a_python_library_to_rust/
• https://alantrick.ca/writings/programming/python_to_rust/
• http://lucumr.pocoo.org/2015/5/27/rust-for-pythonistas/

WebAssembly (abbrevated a wasm) is an emerging technology.

• https://www.rust-lang.org/what/wasm
• https://blog.mgattozzi.dev/rust-wasm/
• https://github.com/rustwasm

AWS Lambda:

• https://github.com/softprops/lando
• https://github.com/srijs/rust-aws-lambda
  • Related: https://github.com/LegNeato/aws-lambda-events
    • Related: https://github.com/graphql-rust
• https://github.com/softprops/serverless-rust

Use Rust with Android NDK:

• https://www.reddit.com/r/rust/comments/b14wah/rust_library_for_ios_and_android_native/
• https://users.rust-lang.org/t/rust-on-android-today/17884/12

Users of the Rust programming language: https://communitywiki.org/trunk/grab/Rustaceans

• https://www.reddit.com/r/rust/comments/b3vw8w/alexis_beingessners_learning_rust_with_entirely/
• https://www.reddit.com/r/rust/comments/cra26t/sonata_100_rust_audio_decoders_media_demuxers_and/
• https://www.reddit.com/r/rust/comments/cysvjh/what_are_some_amazing_softwaresoftware_clones/
• https://www.reddit.com/r/rust/comments/cxmki8/introduction_to_rust_web_applications/
• https://www.reddit.com/r/rust/comments/cm7rje/rust_language_cheat_sheet/

• Operating Systems (Kernel hacking)
  • Create a small operating system in Rust - You can learn Rust by creating a small OS. This is an ongoing blog series. I find this pair well with OS theory from the "Operating Systems: Three Easy Pieces" book (a.k.a. the comet book) and CS-537 class by Remzi. (If anyone have compared xv6 to Blog OS, please let me know.)
• Low-level Programming (core utilities, tools, emulators, embedded programming)

Problems and issues I encountered.

• Solutions from StackOverflow
  • https://stackoverflow.com/questions/29403920/whats-the-difference-between-use-and-extern
  • https://stackoverflow.com/questions/36604010/how-can-i-build-multiple-binaries-with-cargo

Not so useful knowledge.

• Rust history
  • https://www.reddit.com/r/rust/comments/7qels2/i_wonder_why_graydon_hoare_the_author_of_rust/
  • https://github.com/graydon/rust/wiki/Meetings
• Rust Core team
  • https://github.com/nikomatsakis
  • https://github.com/alexcrichton
  • Graydon Hoare
    • https://www.reddit.com/r/rust/comments/7v5kyk/rust_creator_graydon_hoare_says_current_software/
    • https://thenewstack.io/rust-creator-graydon-hoare-talks-about-security-history-and-rust/
  • ... and more

• Awesome Rust
• rust-learning - A bunch of links to blog posts, articles, videos, etc for learning Rust.

Stuffs I referenced in Nov 2019 while learning Rust again by reading "The Rust Programmming Language" book.

• Rust for loop odd step
  • https://zsiciarz.github.io/24daysofrust/book/vol1/day2.html
  • https://www.cs.brandeis.edu/~cs146a/rust/doc-02-21-2015/book/compound-data-types.html
• Rust system of ownership Euler
  • https://www.jonathanturner.org/2015/10/lessons-from-first-12-euler-problems-in.html
  • https://hellocode.dev/rust-ownership
• Rust ownership guide / mastering rust ownership / rust ownership kata / rust ownership practice
  • https://words.steveklabnik.com/pointers-in-rust-a-guide
  • Graphical depiction of ownership and borrowing in Rust
  • Borrow visualizer for the Rust Language Service
• Destructure tuple struct
  • https://learning-rust.github.io/docs/b2.structs.html
• What is Rust Trait
  • https://stevedonovan.github.io/rustifications/2018/09/08/common-rust-traits.html
• Rust match expression and Option enum
  • https://oribenshir.github.io/afternoon_rusting/blog/enum-and-pattern-matching-part-1
• PostgreSQL Extension in C with Rustlang
• Rust crates to use in multithreaded
  • https://stjepang.github.io/2019/01/29/lock-free-rust-crossbeam-in-2019.html
  • ... and many more.
• Rust at speed — building a fast concurrent database
• Project Idea:
  • Building an SQL database with 10 Rust beginners
  • Tutorial: Getting Started with Rust by Building a Tiny Markdown Compiler
  • A Tiny, Static, Full-Text Search Engine using Rust and WebAssembly