Rust is a systems programming language that focuses on three key guarantees:

• Memory Safety: Rust eliminates entire classes of bugs at compile time through its ownership system, preventing null pointer dereferences, buffer overflows, and data races without requiring a garbage collector.
• Performance: Rust provides zero-cost abstractions and compiles to native code, offering performance comparable to C and C++ while maintaining high-level ergonomics.
• Concurrency: The ownership and type system enables fearless concurrency, where the compiler prevents data races and ensures thread safety at compile time.

The Rust ecosystem has matured significantly:

• Industry Adoption: Major companies (Microsoft, Google, Amazon, Meta) are using Rust for critical infrastructure. Linux kernel now supports Rust modules.
• Tooling: The cargo package manager and build system provides dependency management, testing, documentation, and benchmarking out of the box.
• Community: Over 100,000 crates (packages) on crates.io, covering everything from web frameworks to embedded systems.
• Async Runtime: Mature async/await support with frameworks like Tokio and async-std enabling high-performance concurrent applications.
• WebAssembly: First-class support for compiling to WASM, making Rust a popular choice for high-performance web applications.

Rust's ownership system is its most distinctive feature:

• Ownership Rules:
  1. Each value has a single owner
  2. When the owner goes out of scope, the value is dropped
  3. Values can be moved or borrowed
• Borrowing: References allow you to refer to values without taking ownership
  • Immutable references (&T): Multiple allowed simultaneously
  • Mutable references (&mut T): Only one allowed at a time

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);  // Borrowing
    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}  // s goes out of scope but doesn't drop the String

Rust uses Result and Option types for explicit error handling:

• Result<T, E>: For operations that can fail
  • Ok(T): Success case containing value
  • Err(E): Error case containing error
• Option<T>: For values that might be absent
  • Some(T): Contains a value
  • None: No value present

use std::fs::File;
use std::io::Read;

fn read_file(path: &str) -> Result<String, std::io::Error> {
    let mut file = File::open(path)?;  // ? operator propagates errors
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn find_user(id: u32) -> Option<User> {
    if id == 1 {
        Some(User { name: "Alice".to_string() })
    } else {
        None
    }
}

Pattern matching provides exhaustive case analysis:

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn process_message(msg: Message) {
    match msg {
        Message::Quit => println!("Quitting"),
        Message::Move { x, y } => println!("Moving to ({}, {})", x, y),
        Message::Write(text) => println!("Text: {}", text),
        Message::ChangeColor(r, g, b) => println!("RGB({}, {}, {})", r, g, b),
    }
}

// if let for single pattern
if let Some(value) = optional_value {
    println!("Got: {}", value);
}

Traits define shared behavior, similar to interfaces:

trait Summary {
    fn summarize(&self) -> String;
}

struct Article {
    headline: String,
    content: String,
}

impl Summary for Article {
    fn summarize(&self) -> String {
        format!("{}: {}", self.headline, self.content)
    }
}

// Generic function with trait bounds
fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}

// Multiple trait bounds
fn compare<T: Summary + Display>(a: &T, b: &T) { }

Cargo is Rust's build system and package manager:

• Creating a project: cargo new project_name
• Building: cargo build (debug) or cargo build --release
• Running: cargo run
• Testing: cargo test
• Documentation: cargo doc --open

Example Cargo.toml:

[package]
name = "my_project"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1.35", features = ["full"] }
reqwest = "0.11"

[dev-dependencies]
criterion = "0.5"

• Mutability: Variables are immutable by default; use mut keyword for mutability
• Types:
  • Primitives: i32, u64, f64, bool, char
  • Structs: Custom data types with named fields
  • Enums: Types that can be one of several variants
• Scope:
  • Closure: Anonymous functions that can capture environment
  • Shadowing: Redeclaring variables with the same name
• Pattern matching: Exhaustive matching on enum variants and other types
• Package management: Cargo handles dependencies, building, testing
• Building: Compile-time guarantees ensure runtime safety
• Deployment: Single binary output, no runtime dependencies

• Rust Learning Page: Official learning hub
• The Rust Programming Language Book: Comprehensive guide for beginners
• Rust by Example: Learn by working through examples
• Rust Playground: Browser-based environment for experimenting with Rust

• The Rustonomicon: Advanced unsafe Rust
• Async Programming in Rust: Deep dive into async/await
• The Rust Reference: Complete language specification

• Exercism Rust Track: Programming exercises with mentoring
• Rustlings: Small exercises to get you used to reading and writing Rust
• Rust Users Forum: Community discussion and help
• r/rust: Reddit community for Rust programmers

• Rust and WebAssembly Book: Building web applications with Rust
• The Embedded Rust Book: Embedded systems programming
• The Cargo Book: In-depth guide to Cargo