Thinkful vs Bloc für Rust-Programmierung 2026: Bootcamp-Vergleich und Selbststudium-Leitfaden

// Ownership-System verhindert häufige Speicherfehler
fn demonstrate_ownership() {
    let original = String::from("Hallo Rust");
    let moved = original; // Ownership transferiert
    
    // original kann hier nicht mehr verwendet werden
    // Der Compiler verhindert Use-after-move Fehler
    println!("Wert: {}", moved);
}

// Borrowing ermöglicht sichere Referenzen
fn demonstrate_borrowing() {
    let data = vec![1, 2, 3, 4, 5];
    
    // Immutable Borrow - mehrere gleichzeitig erlaubt
    let sum: i32 = data.iter().sum();
    println!("Summe: {}", sum);
    
    // Originaldaten bleiben verfügbar
    println!("Länge: {}", data.len());
}

// Grundlegende Datentypen und Strukturen
struct Developer {
    name: String,
    experience_years: u32,
    skills: Vec<String>,
}

impl Developer {
    fn new(name: &str, experience: u32) -> Self {
        Developer {
            name: name.to_string(),
            experience_years: experience,
            skills: Vec::new(),
        }
    }
    
    fn add_skill(&mut self, skill: &str) {
        self.skills.push(skill.to_string());
    }
    
    fn display_profile(&self) {
        println!("Name: {}", self.name);
        println!("Erfahrung: {} Jahre", self.experience_years);
        println!("Skills: {:?}", self.skills);
    }
}

fn main() {
    let mut dev = Developer::new("Max Mustermann", 3);
    dev.add_skill("Rust");
    dev.add_skill("Systems Programming");
    dev.display_profile();
}

use std::fs::File;
use std::io::{self, Read};

// Explizite Fehlerbehandlung mit Result
fn read_config_file(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

// Pattern Matching für Fehlerbehandlung
fn process_configuration() {
    match read_config_file("config.toml") {
        Ok(config) => {
            println!("Konfiguration geladen: {} Bytes", config.len());
            // Weitere Verarbeitung
        }
        Err(e) => {
            eprintln!("Fehler beim Laden der Konfiguration: {}", e);
            // Fallback-Logik
        }
    }
}

// Option für optionale Werte
fn find_developer_by_id(id: u32) -> Option<Developer> {
    // Simulierte Datenbankabfrage
    if id == 1 {
        Some(Developer::new("Anna Schmidt", 5))
    } else {
        None
    }
}

use std::env;
use std::process;

struct Config {
    query: String,
    filename: String,
    case_sensitive: bool,
}

impl Config {
    fn build(args: &[String]) -> Result<Config, &'static str> {
        if args.len() < 3 {
            return Err("Nicht genügend Argumente");
        }
        
        let query = args[1].clone();
        let filename = args[2].clone();
        let case_sensitive = env::var("CASE_SENSITIVE").is_ok();
        
        Ok(Config {
            query,
            filename,
            case_sensitive,
        })
    }
}

fn main() {
    let args: Vec<String> = env::args().collect();
    
    let config = Config::build(&args).unwrap_or_else(|err| {
        eprintln!("Fehler bei der Argumentverarbeitung: {}", err);
        process::exit(1);
    });
    
    println!("Suche nach '{}' in '{}'", config.query, config.filename);
}

use axum::{
    routing::{get, post},
    Router, Json,
    extract::Path,
    http::StatusCode,
};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct Task {
    id: u32,
    title: String,
    completed: bool,
}

async fn get_tasks() -> Json<Vec<Task>> {
    let tasks = vec![
        Task { id: 1, title: "Rust lernen".to_string(), completed: false },
        Task { id: 2, title: "Projekt erstellen".to_string(), completed: true },
    ];
    Json(tasks)
}

async fn get_task(Path(id): Path<u32>) -> Result<Json<Task>, StatusCode> {
    // Simulierte Datenbankabfrage
    if id == 1 {
        Ok(Json(Task {
            id: 1,
            title: "Rust lernen".to_string(),
            completed: false,
        }))
    } else {
        Err(StatusCode::NOT_FOUND)
    }
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/tasks", get(get_tasks))
        .route("/tasks/:id", get(get_task));
    
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();
    
    axum::serve(listener, app).await.unwrap();
}

// Lifetimes in Funktionssignaturen
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

// Generics mit Trait Bounds
trait Printable {
    fn print(&self);
}

impl Printable for i32 {
    fn print(&self) {
        println!("Integer: {}", self);
    }
}

impl Printable for String {
    fn print(&self) {
        println!("String: {}", self);
    }
}

fn print_all<T: Printable>(items: &[T]) {
    for item in items {
        item.print();
    }
}

// Struct mit Lifetime-Parameter
struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Achtung: {}", announcement);
        self.part
    }
}