Rust Tutorial

Overview

Rust is a systems programming language developed by Mozilla, first released in 2010. It focuses on safety, speed, and concurrency, providing features like zero-cost abstractions, memory safety, and data race prevention. It is hailed as "the future of systems programming languages."

🚀 Background of Rust

Challenges of Systems Programming

Problems faced by traditional systems programming languages:

// C language memory safety issues
char* dangerous_function() {
    char buffer[100];
    strcpy(buffer, "Hello, World!");
    return buffer; // Dangling pointer!
}

// Memory leak problem
void memory_leak() {
    char* ptr = malloc(1000);
    // Forgot to call free(ptr)
}

Rust's Solution

Rust solves these problems through the ownership system:

// Rust's memory-safe approach
fn safe_function() -> String {
    let message = String::from("Hello, World!");
    message // Ownership transferred, safe return
}

// Automatic memory management
fn no_memory_leak() {
    let data = vec![1, 2, 3, 4, 5];
    // Memory automatically released at end of scope
}

🎯 Rust Core Features

1. Memory Safety

Rust prevents memory errors at compile time:

fn memory_safety_example() {
    let data = vec![1, 2, 3];
    let first = &data[0];

    // data.push(4); // Compile error! Cannot modify while borrowed

    println!("First element: {}", first);
    // Can modify after borrow ends
    data.push(4); // Now it's okay
}

2. Zero-Cost Abstractions

High-level features don't bring runtime overhead:

// Iterators are optimized to simple loops at compile time
fn zero_cost_abstraction() {
    let numbers: Vec<i32> = (1..1000000)
        .filter(|x| x % 2 == 0)
        .map(|x| x * x)
        .collect();
}

// Equivalent manual loop
fn manual_loop() {
    let mut numbers = Vec::new();
    for i in 1..1000000 {
        if i % 2 == 0 {
            numbers.push(i * i);
        }
    }
}

3. Concurrent Safety

Prevents data races at compile time:

use std::thread;

fn concurrent_safety() {
    let counter = std::sync::Arc::new(std::sync::Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = std::sync::Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}

4. Pattern Matching

Powerful pattern matching system:

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

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

🌟 Rust's Advantages

Performance

• Zero-cost abstractions: High-level features don't affect performance
• No garbage collection: Deterministic memory management
• LLVM backend: World-class code optimization

Safety

• Memory safety: Prevents buffer overflows, dangling pointers
• Type safety: Powerful type system
• Concurrent safety: Prevents data races

Productivity

• Cargo package manager: Dependency management and build tool
• Rich ecosystem: Large number of libraries on crates.io
• Excellent error messages: Compiler provides clear error hints

📊 Rust vs Other Languages

Feature	Rust	C++	Go	JavaScript
Memory Safety	✅ Compile time	❌ Manual	✅ GC	✅ GC
Performance	✅ Very High	✅ Very High	✅ High	❌ Medium
Concurrency	✅ Safe	❌ Dangerous	✅ Simple	✅ Async
Learning Curve	❌ Steep	❌ Steep	✅ Gentle	✅ Gentle
Ecosystem	✅ Fast Growing	✅ Mature	✅ Growing	✅ Huge

🏢 Rust Use Cases

Systems Programming

// Operating system kernel
pub struct Kernel {
    memory_manager: MemoryManager,
    scheduler: Scheduler,
    file_system: FileSystem,
}

impl Kernel {
    pub fn boot() -> Self {
        Self {
            memory_manager: MemoryManager::new(),
            scheduler: Scheduler::new(),
            file_system: FileSystem::new(),
        }
    }
}

Web Backend Development

// Using Actix-web framework
use actix_web::{web, App, HttpResponse, HttpServer, Result};

async fn hello() -> Result<HttpResponse> {
    Ok(HttpResponse::Ok().body("Hello, Rust!"))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new().route("/hello", web::get().to(hello))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

Blockchain and Cryptocurrency

// Simple block structure
#[derive(Debug, Clone)]
pub struct Block {
    pub index: u64,
    pub timestamp: u64,
    pub data: String,
    pub previous_hash: String,
    pub hash: String,
}

impl Block {
    pub fn new(index: u64, data: String, previous_hash: String) -> Self {
        let timestamp = current_timestamp();
        let hash = calculate_hash(index, &timestamp, &data, &previous_hash);

        Block {
            index,
            timestamp,
            data,
            previous_hash,
            hash,
        }
    }
}

Game Development

// Using Bevy game engine
use bevy::prelude::*;

#[derive(Component)]
struct Player {
    speed: f32,
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_systems(Startup, setup)
        .add_systems(Update, player_movement)
        .run();
}

fn setup(mut commands: Commands) {
    commands.spawn((
        SpriteBundle::default(),
        Player { speed: 100.0 },
    ));
}

🚀 Famous Rust Projects

Open Source Projects

• Firefox - Mozilla browser engine
• Dropbox - File storage service
• Discord - Voice chat application
• Cloudflare - CDN service

System Tools

# Modern system tools
cargo install ripgrep    # Alternative to grep
cargo install fd-find    # Alternative to find
cargo install bat        # Alternative to cat
cargo install exa        # Alternative to ls

🎓 Tips for Learning Rust

Progressive Approach

1. Master basic syntax: Variables, functions, control flow
2. Understand ownership: Rust's most important concept
3. Learn error handling: Result and Option types
4. Practice projects: Start with small projects

Common Pitfalls

// Pitfall 1: Overusing clone()
fn bad_practice(data: &Vec<String>) -> Vec<String> {
    data.clone() // Unnecessary cloning
}

fn good_practice(data: &[String]) -> Vec<&str> {
    data.iter().map(|s| s.as_str()).collect()
}

// Pitfall 2: Ignoring compiler warnings
fn ignore_compiler() {
    let mut x = 5;
    // warning: variable does not need to be mutable
    println!("{}", x);
}

📝 Chapter Summary

Through this chapter, you should understand:

Rust's Characteristics

• ✅ Memory safety and concurrent safety
• ✅ Zero-cost abstractions and high performance
• ✅ Modern language features
• ✅ Active community and ecosystem

Learning Directions

1. Systems programming: Operating systems, databases, network services
2. Web development: Backend services, microservices architecture
3. Game development: High-performance game engines
4. Blockchain: Cryptocurrency and smart contracts

Next Steps

Start setting up the Rust development environment to prepare for actual programming.

---

Continue learning: Next Chapter - Rust Environment Setup