Learning rust

• Rustlings
• Book: The Rust Programming Language by Steve Klabnik & Carol Nichols
• Rust Community
• https://practice.course.rs/why-exercise.html
• https://course.rs/about-book.html
• https://doc.rust-lang.org/rust-by-example/

Other Rust Resources

The Rust community has created a wealth of high-quality and free resources online.

Below resources referred from the Google Comprehensive Rust course

Official Documentation

The Rust project hosts many resources. These cover Rust in general:

• The Rust Programming Language: the canonical free book about Rust. Covers the language in detail and includes a few projects for people to build.
• Rust By Example: covers the Rust syntax via a series of examples which showcase different constructs. Sometimes includes small exercises where you are asked to expand on the code in the examples.
• Rust Standard Library: full documentation of the standard library for Rust.
• The Rust Reference: an incomplete book which describes the Rust grammar and memory model.
• The Cargo Book
• Rust Compiler Development Guide
• Rust 2024

More specialized guides hosted on the official Rust site:

• The Rustonomicon: covers unsafe Rust, including working with raw pointers and interfacing with other languages (FFI).
• Asynchronous Programming in Rust: covers the new asynchronous programming model which was introduced after the Rust Book was written.
• The Embedded Rust Book: an introduction to using Rust on embedded devices without an operating system.
• The Rust Unstable Book

Unofficial Learning Material

A small selection of other guides and tutorial for Rust:

• Learn Rust the Dangerous Way: covers Rust from the perspective of low-level C programmers.
• Rust for Embedded C Programmers: covers Rust from the perspective of developers who write firmware in C.
• Rust for professionals: covers the syntax of Rust using side-by-side comparisons with other languages such as C, C++, Java, JavaScript, and Python.
• Rust on Exercism: 100+ exercises to help you learn Rust.
• Ferrous Teaching Material: a series of small presentations covering both basic and advanced part of the Rust language. Other topics such as WebAssembly, and async/await are also covered.
• Beginner's Series to Rust and Take your first steps with Rust: two Rust guides aimed at new developers. The first is a set of 35 videos and the second is a set of 11 modules which covers Rust syntax and basic constructs.
• Learn Rust With Entirely Too Many Linked Lists: in-depth exploration of Rust's memory management rules, through implementing a few different types of list structures.
• Rustonomicon Book
• Rust Books Reference
• Rust-for-Linux
• Linux Kernel Rust Development Environment
• 100 Exercises To Learn Rust
• Rust-Advanced-Testing-Workshop
• awesome-rust
• Let's Get Rusty - Rust Resources
• Mainmatter's 100 day's to Rust
• 24 days of Rust
• 24 days of hackage by Ollie Charles
• Rust Cryptography
• Collection of traits which describe functionality of cryptographic primitives
• Algorithms and Data Structures of all kinds written in Rust
• The Little Book of Rust Macros
• Gray-Scott with Rust - Writing High Performance Computing (HPC) in Rust!
• Comprehensive Rust 🦀

Online Articles

• Rust-Macros
• The Four Horsemen of Bad Rust Code
• Long-term Rust Project Maintenance
• Rust 1.78: Performance Impact of the 128-bit Memory Alignment Fix
• How to build a plugin system in Rust
• RUST TYPESTATE PATTERN
• The Sage Programming Language
• Learning Material for Idiomatic Rust
• Project Euler - Problem Archives
• Claiming, auto and otherwise
• The definitive guide to error handling in Rust
• Master hexagonal architecture in Rust
• From Sender to Receiver: Rust’s Approach to Local File Transfers
• Memory Safety in C++ vs Rust vs Zig
• Writing production Rust macros with macro_rules!
• Implementing a generic range parser in Rust
• The missing parts in Cargo
• Build with Naz : Box and Pin exploration in Rust
• Procedural Macros in Rust – A Handbook for Beginners
• Rust Number Types Explained
• Rust's Mutex, Atomics and UnsafeCell – Spooky Action at a Distance?
• Myths and Legends about Integer Overflow in Rust
• Why am I writing a Rust compiler in C?
• How Asynchronous Programming Works in Rust – Futures and Async/Await Explained with Examples
• Deploying Rust in Existing Firmware Codebases
• Rust to Assembly: Understanding the Inner Workings of Rust
• Rust - A low-level echo server using io_uring
• Understanding Memory Ordering in Rust
• Learning Rust as a C/Python programmer
• A Simplified Comparison: Rust and Pointers
• Serde for trait objects - Part 1: Overview
• Serde for trait objects - Part 2: Serialization
• Serde for trait objects - Part 3: Deserialization
• Nine Rules for Running Rust on Embedded Systems
• Async Rust in Three Parts
• Impl Snake For Micro:bit - Embedded async Rust on BBC Micro:bit with Embassy
• Tutorial: Implementing JSON parsing (Rust)
• Rust needs an official specification

Interesting Rust Projects

• Rust - Implementing WebSockets
• Rust - Base64 encoding and decoding
• Rust - Implementing SHA-1
• LearnRust
• Rustlings Rewrite
• Teaching Rust
• Teach-rs
• Different Filesystems Implementations over FUSE
• Writing a Simple Filesystem Using FUSE in C
• Are we web yet?
• Rust Technology
• Writing Interpreters in Rust: a Guide
• hecto: Build Your Own Text Editor in Rust
• Writing an OS in Rust
• Tutorial: Implementing JSON parsing (Rust)

YouTube Videos to look for (what I watched until now)

• All Rust features explained
• Visualizing memory layout of Rust's data types
• "Intro to Monads for Rustaceans" (July 2022)
• Rust Cryptography Series by Uncloak Cryptography
• Intro To Rust Cryptography: Hashing with SHA2
• Understanding Rust Closures aka. Anonymous Functions 🦀 💻
• Rust Match Expressions and Patterns 🦀
• Decrusting the serde crate
• How Rust's println! macro really works
• Linting Rust Code With Clippy CLI Rules 🤯🦀 Rust Programming Tutorial for Developers
• Intro to Rust Async Function Execution With Smol 🦀 Rust Programming Tutorial for Developers
• Intro Guide to Rust Documentation With Rustdoc 🦀 Rust Tutorial for Developers
• Crafting an Interpreter in Rust #01: Basic Bytecode Chunks
• Crafting an Interpreter in Rust #02: First Virtual Machine
• Building a web app from Scratch
• Async Rust: the good, the bad, and the ugly - Steve Klabnik
• Rust's Alien Data Types 👽 Box, Rc, Arc

Rust Books Recommendation

• Claus Matzinger • Learn Rust Programming • https://amzn.to/3PeN0Fx
• Tim McNamara • Rust in Action • https://amzn.to/3ux2R9u
• Brenden Matthews • Code Like a Pro in Rust • https://amzn.to/3LFAyy9
• Prabhu Eshwarla • Rust Servers, Services & Apps • https://amzn.to/3yV13br
• Bastian Gruber • Rust Web Development • https://amzn.to/3lquaQX
• Blandy, Orendorff & Tindall • Programming Rust • https://amzn.to/3x7r6w6
• Ken Youens-Clark • Command-Line Rust • https://amzn.to/3PQZ539
• Kevin Hoffman • Programming WebAssembly with Rust • https://amzn.to/3x3brhe
• Practical Cryptography for Developers
• Explained from First Principles - Number Theory
• Cryptography in Rust for Hackers

Please see the Little Book of Rust Books for even more Rust books.

Other Supporting Resources

• CS 225: Introduction to Data Structures and Algorithms with C++
• Rust Compiler Development Guide
• Rust-analyzer Documentation

Embedded Rust

• Embedded Rust Weekely Newsletter
• A 5-Step Guide For Learning Embedded Rust
• STM32F4 with Embedded Rust at the HAL
• https://thejpster.org.uk/blog/blog-2024-08-08/
• Embedded Rust Contribution Guide
• Developing a cryptographically secure bootloader for RISC-V in Rust
• Pico Pico - Embedded Programming with Rust

Miscellaneous

• The AOSP and AAOS Meetup
• Cryptography 101 with Alfred Menezes