2026'da Rust Öğrenmek için Thinkful vs Bloc: Bootcamp Karşılaştırması ve Kendi Kendine Öğrenme Rehberi

// Garbage collector olmadan bellek güvenliği
fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone(); // Açık klonlama
    
    println!("s1 = {}, s2 = {}", s1, s2);
}

// Rust'ta hata işleme örneği
use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut file = File::open("username.txt")?;
    let mut username = String::new();
    file.read_to_string(&mut username)?;
    Ok(username)
}

// Rust'ta temel veri yapıları
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

impl User {
    fn new(username: String, email: String) -> User {
        User {
            username,
            email,
            sign_in_count: 1,
            active: true,
        }
    }
    
    fn deactivate(&mut self) {
        self.active = false;
    }
}

// Generics bölümünden örnek
fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    
    largest
}

fn main() {
    let numbers = vec![34, 50, 25, 100, 65];
    let result = largest(&numbers);
    println!("En büyük sayı: {}", result);
}

// Pattern matching - Rust'ın temel konsepti
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn process_message(msg: Message) {
    match msg {
        Message::Quit => println!("Program sonu"),
        Message::Move { x, y } => println!("({}, {}) konumuna taşındı", x, y),
        Message::Write(text) => println!("Metin: {}", text),
        Message::ChangeColor(r, g, b) => {
            println!("Renk RGB({}, {}, {}) olarak değiştirildi", r, g, b)
        }
    }
}

// Gelişmiş özellikler - lifetime'lar
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

// Rust'ta async/await
async fn fetch_data(url: &str) -> Result<String, reqwest::Error> {
    let response = reqwest::get(url).await?;
    let body = response.text().await?;
    Ok(body)
}

// Rust'ta basit bir CLI örneği
use clap::{App, Arg};
use std::fs;

fn main() {
    let matches = App::new("File Counter")
        .version("1.0")
        .author("Developer")
        .about("Dosyalardaki satırları sayar")
        .arg(
            Arg::with_name("file")
                .short('f')
                .long("file")
                .value_name("FILE")
                .help("Dosya yolu")
                .required(true),
        )
        .get_matches();

    if let Some(file_path) = matches.value_of("file") {
        match fs::read_to_string(file_path) {
            Ok(contents) => {
                let line_count = contents.lines().count();
                println!("{} dosyası {} satır içeriyor", file_path, line_count);
            }
            Err(e) => eprintln!("Hata: {}", e),
        }
    }
}

// Axum ile basit HTTP sunucusu
use axum::{
    routing::get,
    Router,
    Json,
};
use serde::Serialize;

#[derive(Serialize)]
struct Health {
    status: String,
    version: String,
}

async fn health_check() -> Json<Health> {
    Json(Health {
        status: "ok".to_string(),
        version: "1.0.0".to_string(),
    })
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/health", get(health_check));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();
    
    axum::serve(listener, app).await.unwrap();
}

// Rustlings'ten örnek - hataları düzeltme
// Orijinal görev:
// fn main() {
//     let x = 5;
//     x = 6; // Hata: değişmez değişkene iki kez atama yapılamaz
// }

// Çözüm:
fn main() {
    let mut x = 5;
    println!("x'in değeri: {}", x);
    x = 6;
    println!("x'in yeni değeri: {}", x);
}

// Sık sorulan soru: &str ile String arasındaki fark nedir?
fn string_vs_str() {
    // String - sahip olunan, değiştirilebilir, heap'te tahsis edilmiş
    let mut owned: String = String::from("Hello");
    owned.push_str(", World!");
    
    // &str - ödünç alınmış, değiştirilemez, heap veya stack'i işaret edebilir
    let borrowed: &str = "Hello, World!";
    
    // Dönüşüm
    let to_string: String = borrowed.to_string();
    let to_str: &str = &owned;
}

// Smart pointer'lar hakkında soru
use std::rc::Rc;
use std::cell::RefCell;

fn smart_pointers_example() {
    // Box - heap üzerinde tekil sahiplik
    let boxed = Box::new(5);
    
    // Rc - referans sayımı (tek thread)
    let shared = Rc::new(vec![1, 2, 3]);
    let clone = Rc::clone(&shared);
    
    // RefCell - interior mutability
    let mutable = RefCell::new(5);
    *mutable.borrow_mut() += 1;
}