Kenhuang Academy
  • English

      • 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

      FeatureRustC++GoJavaScript
      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