Rust Language

[sebmaz93]

What is the title of the roadmap you are submitting?

Roadmap to learn Rust

Is this roadmap prepared by you or someone else?

I prepared this roadmap

Roadmap Items

• Foundations

  • Introduction to Rust
    • What is Rust?
    • Why use Rust?
    • Memory Safety and Zero-Cost Abstractions
  • Environment Setup
    • Installing Rust and Cargo
    • IDEs and Rust Toolchains
    • Rust REPL (Rust Playground)

• Language Basics

  • Syntax and Semantics
    • Variables, Constants, and Data Types
    • Control Flow Constructs
    • Functions and Method Syntax
    • Pattern Matching and Destructuring
  • Ownership System
    • Ownership Rules and Memory Safety
    • Borrowing, References, and Slices
    • Deep Dive: Stack vs Heap
  • Data Structures
    • Integers, Floats, Boolean, Character,
    • Tuple, Array
    • Vector, String, HashMap, HashSet
    • LinkedList, BinaryHeap, Stack, Queue
    • Advanced: BTreeMap, BTreeSet, Rc, Arc, Mutex, RwLock, Channels
  • Constructs
    • Enums, Structs, Traits, Impl blocks

• Intermediate Concepts

  • Error Handling
    • Option & Result Enumerations
    • Propagating Errors and ? Operator
    • Custom Error Types and Traits
  • Modules and Crates
    • Code Organization and Namespacing
    • Dependency Management with Cargo.toml
    • Publishing to crates.io
  • Concurrency and Parallelism
    • Threads, Channels, and Message Passing
    • Atomic Operations and Memory Barriers
    • Futures and Async/Await Paradigm

• Advanced Topics

  • Traits and Generics
    • Trait Definitions and Implementations
    • Trait Bounds and Associated Types
    • Advanced Generics and Type-level Programming
  • Lifetimes and Borrow Checker
    • Explicit Lifetime Annotations
    • Lifetime Elision Rules
    • Covariant and Contravariant Lifetimes
  • Macros and Metaprogramming
    • Declarative Macros with macro_rules!
    • Procedural Macros and Custom Derive
    • Domain-Specific Languages (DSLs) in Rust

• Ecosystem and Libraries

  • Web Development
    • Rocket: A web framework with a focus on usability, security, extensibility, and speed.
    • Warp: A web server framework with a focus on composability and strongly typed APIs.
    • Actix: An actor system and web framework for Rust.
    • Yew: A modern Rust framework for creating multi-threaded frontend apps with WebAssembly.
  • Asynchronous Programming
    • Tokio: A runtime for writing reliable, asynchronous, and slim applications.
    • async-std: Asynchronous version of the Rust standard library.
    • smol: A small and fast async runtime.
  • Networking
    • reqwest: An ergonomic, batteries-included HTTP client.
    • hyper: A low-level HTTP implementation.
    • quinn: Futures-based QUIC implementation in Rust.
  • Serialization/Deserialization
    • Serde: A framework for serializing and deserializing Rust data structures.
    • json-rust: JSON implementation in Rust.
    • toml-rs: A TOML decoder/encoder.
  • Database and ORM
    • Diesel: A safe, extensible ORM and query builder.
    • sqlx: Asynchronous, pure Rust SQL crate featuring compile-time checked queries.
    • rusqlite: SQLite bindings for Rust.
  • Cryptography
    • ring: Safe, fast, small crypto using Rust.
    • rust-crypto: A (mostly) pure-Rust implementation of various cryptographic algorithms.
    • sodiumoxide: Rust bindings to the libsodium library.
  • Command Line Utilities
    • clap: A simple-to-use, efficient, and full-featured library for parsing command line arguments.
    • structopt: Parse command line arguments by defining a struct.
    • termion: Pure Rust, bindless library for low-level handling, manipulating, and reading information about terminals.
  • Game Development
    • bevy: A refreshingly simple data-driven game engine built in Rust.
    • fyrox: 3D and 2D game engine
    • ggez: A lightweight game framework for making 2D games.
    • macroquad: cross-platform game engine.
    • wgpu-rs: Rust bindings to WebGPU.
  • GUI Development
    • druid: A data-first Rust-native UI design toolkit.
    • gtk-rs: Rust bindings and wrappers for GLib, GDK 3, GTK+ 3, and Cairo.
    • relm: An asynchronous, GTK+-based, GUI library, inspired by Elm.
  • Embedded and Systems Programming
    • embedded-hal: A Hardware Abstraction Layer (HAL) for embedded systems.
    • rppal: Raspberry Pi Peripheral Access Library.
    • nrf-hal: Peripheral access API for the nRF52 series microcontrollers.
  • WebAssembly (Wasm)
    • wasm-bindgen: Facilitate high-level interactions between Wasm modules and JavaScript.
    • wasm-pack: Pack up the wasm and publish it to npm.
    • wasmer: A fast and secure WebAssembly runtime.

• Best Practices and Tooling

  • Testing and Debugging
    • Unit and Integration Testing
    • Mocking and Property-based Testing
    • Debugging Tools: rust-gdb and rust-lldb
  • Documentation
    • Writing Quality Documentation with rustdoc
  • Performance and Profiling
    • Benchmarking with Criterion.rs

[sebmaz93]

should I start making changes on code level (add rust folder .md file ..etc) and open PR for it ? or must wait and get approval ?

[thomaszdxsn]

how the svg data.json made? anybody know?

[ShawnNectar]

maybe getting more into types would be a good deal, even the basics of it. Since you are giving a well grounded introduction, why not the good and old math:>

[sebmaz93]

@ShawnNectar you mean more detailed types like integers have i8 u8 i16 u16...etc ? or Types like Option Result<T, E> ...etc ?

[ShawnNectar]

sure yeah! don't need to go super deep into every nomenclature difference. Keeping it simple should do the trick, just explain why they are what they are. Can also touch on inference, Rust's type system, and how formal proof fits into the mix

[ShawnNectar]

formal proof is boring, but it's great to know at least the little little basics, rust loves formal proof:> even though we don't

[kamranahmedse]

Thanks @sebmaz93 -- roadmap for rust is live 🙏