Rust Incubator

It wasn’t always so clear, but the Rust programming language is fundamentally about empowerment: no matter what kind of code you are writing now, Rust empowers you to reach farther, to program with confidence in a wider variety of domains than you did before.

Rust Book's Foreword

This project represents a hard-way step-by-step Rust learning course from language basics to a capability of web backend development.

Prerequisites

Toolchain

• rustup for installing Rust toolchain and keeping it up-to-date.
• CLion/IntelliJ IDEA + IntelliJ Rust + Toml plugins as development environment (or any other on your choice).

Bookshelf

• Rust Book teaches and explains Rust basics.
• Rust By Example teaches you Rust basics using editable examples.
• Rust Reference is not a formal spec, but is more detailed and comprehensive than the Rust Book.
• Cheats.rs and Rust SVG Cheatsheet for quick reference.
• Rust Edition Guide for considering improvements of Rust 2018 and Rust 2021.
• Rust std lib documentation.
• Cargo Book is a guide to Cargo, Rust's build tool and dependency manager.
• Rustdoc Book is a guide to rustdoc documentation tool.
• Rust Cookbook is a collection of simple examples that demonstrate good practices to accomplish common programming tasks, using the crates of the Rust ecosystem.
• Rust Design Patterns is an open source repository of Rust design patterns and idioms.
• Effective Rust is a collection of guidelines that had been learned from real world experience of creating software in Rust.
• Rust API Guidelines is a set of recommendations on how to design and present APIs for Rust.
• Rust FAQ answers common question about Rust.
• Rust Playground allows to share and check runnable Rust code snippets online.
• Awesome Rust is a curated list of Rust code and resources.
• This Week in Rust represents handpicked and subscribable Rust weekly updates.
• Baby Steps blog of Nicholas Matsakis shares useful Rust patterns, ideas and design decisions.

Steps

Before you start

1. Create a new GitHub repository for yourself using this one as template.
2. Invite as a collaborator of your repository the person you want to review your lessons (mentor or lead).

NOTE: This learning course is constantly improving and evolving over time.

To be up-to-date with the recent changes in your own copy of this repository, attach the upstream history with the following commands:

git remote add upstream https://github.com/instrumentisto/rust-incubator.git
git fetch upstream main
git merge upstream/main --allow-unrelated-histories

And then, whenever you want to grab some new changes, do the following:

git fetch upstream main
git merge upstream/main

Additionally, to be aware about new changes, you may either watch this repository on GitHub, or even track it via RSS subscription.

Schedule

Each step must be performed as a separate PR (pull request) with an appropriate name and checkmarked here in README's schedule after completion. Each step is a Cargo workspace member, so you can run/test it from the project root (i.e. cargo run -p step_1_8). Consider to use rustfmt and Clippy when you're writing Rust code.

Each step has the estimated time for completion. If any deeper investigation on step's theme is needed by you, then it's on your own.

Do not hesitate to ask your mentor/lead with questions, however you won't receive any concrete answer, but rather a direction for your own investigation. Mentor/Lead is the one who asks questions here, demanding concrete and complete answers.

• 0. Become familiar with Rust basics (3 days)
• 1. Concepts (2 days, after all sub-steps)
  • 1.1. Default values, cloning and copying (1 day)
  • 1.2. Boxing and pinning (1 day)
  • 1.3. Shared ownership and interior mutability (1 day)
  • 1.4. Clone-on-write (1 day)
  • 1.5. Conversions, casting and dereferencing (1 day)
  • 1.6. Static and dynamic dispatch (1 day)
  • 1.7. Sized and ?Sized types (1 day)
  • 1.8. Thread safety (1 day)
  • 1.9. Phantom types (1 day)
• 2. Idioms (2 days, after all sub-steps)
  • 2.1. Rich types ensure correctness (1 day)
  • 2.2. Swapping values with mem::replace (1 day)
  • 2.3. Bound behavior, not data (1 day)
  • 2.4. Abstract type in, concrete type out (1 day)
  • 2.5. Exhaustivity (1 day)
  • 2.6. Sealing (1 day)
• 3. Common ecosystem (2 days, after all sub-steps)
  • 3.1. Testing and mocking (1 day)
  • 3.2. Declarative and procedural macros (1 day)
  • 3.3. Date and time (1 day)
  • 3.4. Regular expressions and custom parsers (1 day)
  • 3.5. Collections and iterators (1 day)
  • 3.6. Serialization and deserialization (1 day)
  • 3.7. Randomness and cryptography (1 day)
  • 3.8. Logging and tracing (1 day)
  • 3.9. Command-line arguments, environment variables and configs (1 day)
  • 3.10. Multithreading and parallelism (1 day)
  • 3.11. Async I/O, futures and actors (2 days)
• 4. Backend ecosystem (3 days, after all sub-steps)
  • 4.1. Databases, connection pools and ORMs (1 day)
  • 4.2. HTTP servers and clients (1 day)
  • 4.3. API servers, clients and tools (1 day)

More practice

• rustlings are small exercises to get you used to reading and writing Rust code.
• Rust on Exercism provides coding exercises with mentoring.
• Rust Quiz is medium to hard Rust questions with explanations.