Thinkful vs Bloc per Imparare Rust nel 2026: Confronto Bootcamp e Guida all'Autoapprendimento

// Il sistema di ownership previene errori di memoria comuni
fn demonstrate_ownership() {
    let original = String::from("Ciao Rust");
    let moved = original; // Ownership trasferita
    
    // original non può più essere utilizzato qui
    // Il compilatore previene errori use-after-move
    println!("Valore: {}", moved);
}

// Il borrowing consente riferimenti sicuri
fn demonstrate_borrowing() {
    let data = vec![1, 2, 3, 4, 5];
    
    // Borrow immutabile - più borrow simultanei consentiti
    let sum: i32 = data.iter().sum();
    println!("Somma: {}", sum);
    
    // I dati originali rimangono disponibili
    println!("Lunghezza: {}", data.len());
}

// Tipi di dati e strutture fondamentali
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!("Nome: {}", self.name);
        println!("Esperienza: {} anni", self.experience_years);
        println!("Competenze: {:?}", self.skills);
    }
}

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

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

// Gestione esplicita degli errori con 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 per la gestione degli errori
fn process_configuration() {
    match read_config_file("config.toml") {
        Ok(config) => {
            println!("Configurazione caricata: {} byte", config.len());
            // Elaborazione successiva
        }
        Err(e) => {
            eprintln!("Errore nel caricamento della configurazione: {}", e);
            // Logica di fallback
        }
    }
}

// Option per valori opzionali
fn find_developer_by_id(id: u32) -> Option<Developer> {
    // Query database simulata
    if id == 1 {
        Some(Developer::new("Anna Bianchi", 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("Argomenti insufficienti");
        }
        
        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!("Errore nell'elaborazione degli argomenti: {}", err);
        process::exit(1);
    });
    
    println!("Ricerca di '{}' 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: "Imparare Rust".to_string(), completed: false },
        Task { id: 2, title: "Creare progetto".to_string(), completed: true },
    ];
    Json(tasks)
}

async fn get_task(Path(id): Path<u32>) -> Result<Json<Task>, StatusCode> {
    // Query database simulata
    if id == 1 {
        Ok(Json(Task {
            id: 1,
            title: "Imparare Rust".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 nelle signature delle funzioni
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

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

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

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

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

// Struct con parametro lifetime
struct ImportantExcerpt<'a> {
    part: &'a str,
}

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