Rust
Introduction to Rust
Getting started with the Rust programming language.
What is Rust?
Content explaining what Rust is, its origins, and its primary goals (safety, speed, concurrency).
Key Features
Content detailing Rust's key features like memory safety without garbage collection, zero-cost abstractions, and fearless concurrency.
Installation & Setup
Content on installing Rust using `rustup`, and setting up the development environment with Cargo.
Hello, World! & Cargo Basics
Content for writing the first "Hello, World!" program and basic Cargo commands (new, build, run, check).
Rust Fundamentals
Core language constructs and concepts.
Variables & Mutability
Content about variable bindings, mutability, shadowing, and constants.
Data Types
Content on scalar types (integers, floats, booleans, chars) and compound types (tuples, arrays).
Functions
Content on defining functions, parameters, return values, and function expressions.
Control Flow
Content about if expressions, loops (loop, while, for), and conditional logic.
Comments & Documentation
Content on writing comments and generating documentation using `cargo doc`.
Ownership & Borrowing
Rust's core system for memory safety.
Ownership Rules
Content explaining Rust's ownership system and its three main rules.
References & Borrowing
Content on immutable and mutable references, and the rules of borrowing.
Borrow Checker
Content explaining the role of the borrow checker in enforcing memory safety at compile time.
Lifetimes
Content on understanding and specifying lifetimes to ensure references are always valid.
Structs, Enums & Patterns
Creating custom data types and controlling program flow.
Defining Structs
Content on defining and instantiating structs, tuple structs, and unit-like structs.
Defining Enums (Option, Result)
Content on defining enums, including common ones like `Option` and `Result` for error handling.
Pattern Matching
Content on using `match` expressions, `if let`, and other pattern matching constructs.
Collections & Iterators
Working with collections of data and processing them efficiently.
Vectors
Content on using `Vec
Strings & Slices
Content on `String` (owned) and `&str` (string slices), and UTF-8 encoding.
Hash Maps
Content on using `HashMap
Iterators & Closures
Content on using iterators for processing sequences and closures for anonymous functions.
Error Handling
Robust ways to handle errors in Rust.
Recoverable Errors (Result)
Content on using the `Result
Unrecoverable Errors (panic!)
Content on the `panic!` macro for unrecoverable errors.
The '?' Operator
Content on using the `?` operator for concise error propagation.
Generics & Traits
Abstracting code and defining shared behavior.
Generics
Content on using generic type parameters in functions, structs, and enums.
Traits
Content on defining and implementing traits to define shared functionality (similar to interfaces).
Trait Objects
Content on using trait objects for dynamic dispatch.
Concurrency
Writing concurrent and parallel programs safely in Rust.
Threads
Content on creating and managing threads for parallel execution.
Message Passing
Content on using channels for message-passing concurrency.
Async/Await
Content on asynchronous programming in Rust using `async` and `await`.
Modules, Crates & Packages
Organizing and sharing Rust code.
Modules, Crates, Packages
Content explaining Rust's module system for organizing code into crates and packages.
Paths & `use` Keyword
Content on using paths to refer to items and the `use` keyword for bringing paths into scope.
Publishing to Crates.io
Content on publishing crates to the central package registry, Crates.io.
Testing in Rust
Ensuring code quality with Rust's built-in testing features.
Unit Tests
Content on writing and running unit tests.
Integration Tests
Content on writing and running integration tests.
Documentation Tests
Content on writing tests within documentation comments.
Advanced & FFI
Low-level programming and interoperability.
Unsafe Rust
Content on using `unsafe` blocks for operations not guaranteed by the compiler's safety checks.
Foreign Function Interface (FFI)
Content on interfacing Rust code with code written in other languages, particularly C.
Rust for Embedded
Specific considerations for using Rust in embedded environments.
`no_std` Development
Content on developing Rust applications without the standard library for bare-metal and RTOS environments.
HAL & PACs
Content explaining Hardware Abstraction Layers (HAL) and Peripheral Access Crates (PACs) for interacting with hardware.
Real-time Capabilities
Content on using Rust for real-time systems, including RTOS integration and concurrency features.