Thinkful vs Bloc: 2026년 Rust 학습을 위한 부트캠프 비교 및 독학 가이드

// Rust 소유권 시스템의 기본 예제
fn main() {
    let original = String::from("Hello, Rust!");
    let moved = original; // 소유권 이동
    // println!("{}", original); // 컴파일 에러
    println!("{}", moved); // 정상 작동
}

// Thinkful 커리큘럼에서 배우는 에러 핸들링
use std::fs::File;
use std::io::{self, Read};

fn read_file_contents(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)
}

fn main() {
    match read_file_contents("config.toml") {
        Ok(contents) => println!("파일 내용: {}", contents),
        Err(e) => eprintln!("에러: {}", e),
    }
}

// Bloc 프로젝트에서 구축하는 CLI 도구 예제
use std::env;
use std::process;

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

impl Config {
    fn new(args: &[String]) -> Result<Config, &'static str> {
        if args.len() < 3 {
            return Err("인수가 부족합니다");
        }
        let query = args[1].clone();
        let filename = args[2].clone();
        Ok(Config { query, filename })
    }
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let config = Config::new(&args).unwrap_or_else(|err| {
        eprintln!("인수 파싱 에러: {}", err);
        process::exit(1);
    });
    println!("검색: {} in {}", config.query, config.filename);
}

// 비동기 프로그래밍 예제
use tokio;

#[tokio::main]
async fn main() {
    let task1 = tokio::spawn(async {
        println!("태스크1 시작");
        tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
        println!("태스크1 완료");
    });

    let task2 = tokio::spawn(async {
        println!("태스크2 시작");
        tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
        println!("태스크2 완료");
    });

    let _ = tokio::join!(task1, task2);
}

// 기초 단계에서 이해해야 할 구조체와 메서드
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn new(width: u32, height: u32) -> Self {
        Rectangle { width, height }
    }

    fn area(&self) -> u32 {
        self.width * self.height
    }

    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

fn main() {
    let rect1 = Rectangle::new(30, 50);
    let rect2 = Rectangle::new(10, 40);
    println!("면적: {}", rect1.area());
    println!("rect1이 rect2를 포함할 수 있음: {}", rect1.can_hold(&rect2));
}

// 제네릭과 트레이트 실습
trait Summary {
    fn summarize(&self) -> String;
}

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

impl Summary for Article {
    fn summarize(&self) -> String {
        format!("{}: {}...", self.title, &self.content[..50.min(self.content.len())])
    }
}

fn notify<T: Summary>(item: &T) {
    println!("속보: {}", item.summarize());
}

// Actix-web을 사용한 간단한 웹 서버
use actix_web::{web, App, HttpResponse, HttpServer, Responder};

async fn health_check() -> impl Responder {
    HttpResponse::Ok().json(serde_json::json!({
        "status": "healthy",
        "version": "1.0.0"
    }))
}

async fn greet(name: web::Path<String>) -> impl Responder {
    HttpResponse::Ok().body(format!("안녕하세요, {}님!", name))
}

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

// 면접에서 자주 묻는 라이프타임 이해
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("긴 문자열");
    let result;
    {
        let string2 = String::from("짧은");
        result = longest(string1.as_str(), string2.as_str());
        println!("가장 긴 것: {}", result);
    }
}