Rust para Iniciantes: Do Java/Go para Rust

Uma jornada prática e progressiva pelo ecossistema Rust voltada para desenvolvedores com background em Java ou Go.

Neste deck de 20 slides, abordamos os conceitos fundamentais que tornam Rust único — ownership, borrowing, lifetimes e o borrow checker — sempre com comparações diretas com Java e Go para acelerar a curva de aprendizado.

Tópicos cobertos:

- Por que Rust? Performance de C sem garbage collector
- Ownership, Borrowing e Referências — o coração da linguagem
- Structs, Enums e Pattern Matching exaustivo
- Option e Result: adeus NullPointerException
Traits, Generics e Closures
- Concorrência com Arc> e async/await com Tokio
- Crates essenciais: serde, axum, sqlx, tokio e mais
- Testes integrados ao Cargo
- Novidades do Rust 1.94.0 (Mar 2026): array_windows, LazyLock::get, Cargo config include e mais
- Roadmap de estudos Java/Go → Rust

Atualizado para Rust 1.94.0 • rust-lang.org • crates.io • play.rust-lang.org
🦀 "A linguagem mais amada no Stack Overflow por 9 anos consecutivos (2016–2024)"

Transcript

1. ⚙ R U S T Para Iniciantes Do Java/Go para Rust • Versão 1.94.0 • rust-lang.org Performance Segurança Zero-cost Abstractions Sem GC 20 slides • Exemplos práticos • Comparações com Java & Go
2. O que é Rust? Uma linguagem de sistemas moderna criada pela Mozilla 📅 Criação & História  Criada por Graydon Hoare (2006)  Adotada pela Mozilla em 2009  1ª release estável: 2015  Versão atual: 1.94.0 (Mar 2025)  Mantida pela Rust Foundation 🎯 Principais Objetivos  Segurança de memória sem GC  Performance = C/C++  Concorrência segura  Abstrações sem custo  Tooling de classe mundial 🏢 Onde é Usado  WebAssembly (WASM)  Kernel do Linux  Windows NT drivers  AWS, Google, Meta  Dropbox, Cloudflare 🏆 Linguagem mais amada no Stack Overflow por 9 anos consecutivos (2016–2024)
3. Por que Rust? — Java/Go vs Rust Entendendo as diferenças fundamentais Aspecto Java Go Rust Gerenciamento de Memória GC (JVM) GC (tracing) Ownership (sem GC) Performance JVM overhead Boa Equivalente a C Segurança de Memória Parcial (NullPointer) Parcial Garantida em compile-time Concorrência Threads / virtual Goroutines (leve) Fearless Concurrency Tempo de Startup Lento (JVM warm-up) Rápido Muito rápido Curva de Aprendizado Moderada Baixa Alta (mas vale!) 💡 Rust elimina classes inteiras de bugs (use-after-free, data races) em tempo de compilação — sem custo em runtime.
4. Instalação & Toolchain Rustup, Cargo e o ecossistema de ferramentas 🔧 Instalação (rustup) # Linux / macOS curl --proto '=https' --tlsv1.2 \ -sSf https://sh.rustup.rs | sh # Windows: baixar rustup-init.exe # https://rustup.rs rustup update # atualiza toolchain rustup show # versão instalada 📦 Cargo — gerenciador de pacotes cargo new meu_projeto # cria projeto cargo build # compila cargo run # compila + executa cargo test # roda testes cargo add serde # adiciona dep cargo clippy # linter avançado cargo fmt # formata código cargo doc --open # docs locais rustfmt Formatador clippy Linter rust-analyzer LSP / IDE rustdoc Documentação VS Code + extensão rust-analyzer = melhor experiência para iniciantes
5. Hello World & Estrutura de um Projeto Seu primeiro programa em Rust 📄 main.rs fn main() { println!("Olá, Rust! " 🦀 ); } // Saída: // Olá, Rust! 🦀 📁 Estrutura do Cargo meu_projeto/ ├── Cargo.toml ← dependências ├── Cargo.lock ← lock file └── src/ └── main.rs ← código-fonte 📋 Cargo.toml [package] name = "meu_projeto" edition = "2024" version = "0.1.0" [dependencies] serde = { version = "1", features = ["derive"] }
6. Variáveis, Mutabilidade e Tipos let, mut, const e o sistema de tipos estático // Imutável por padrão (como val em Kotlin) let x = 5; // i32 inferido let y: f64 = 3.14; // tipo explícito let nome = "Ferris"; // &str // Mutável — precisa de mut let mut contador = 0; // mut é explícito! contador += 1; // Constantes — sempre tipadas, em SCREAMING_SNAKE_CASE const MAX_PONTOS: u32 = 100_000; // Shadowing — redeclara a variável let x = x * 2; // novo x = 10, original perdido 📊 Tipos Primitivos Tipo Descrição i8..i128 / isize Inteiro com sinal u8..u128 / usize Inteiro sem sinal f32, f64 Ponto flutuante bool true / false char Unicode 4 bytes &str / String String imut / mut () Unit (vazio) (i32, bool) Tuple [i32; 5] Array fixo
7. Ownership — O Coração do Rust A feature mais importante e mais diferente de Java/Go 1 Cada valor tem um dono Toda alocação de memória tem exatamente uma variável responsável. 2 Só um dono por vez Não há dois donos simultâneos do mesmo valor na memória. 3 Dono sai do escopo → drop Quando o dono sai do escopo, a memória é liberada automaticamente. // MOVE — ownership é transferido let s1 = String::from("hello"); let s2 = s1; // s1 MOVE para s2 // println!(s1); ← ERRO de compilação! s1 inválido // CLONE — cópia explícita (como Java .clone()) let s3 = s2.clone(); // s2 e s3 existem // COPY — tipos primitivos são copiados automaticamente let a = 5; let b = a; // a e b são 5 (Copy trait)
8. Borrowing & Referências Emprestar sem transferir ownership // Referência imutável — & (pode ter várias) fn calcular_tamanho(s: &String) -> usize { s.len() } let s1 = String::from("hello"); let len = calcular_tamanho(&s1); // s1 ainda existe! // Referência mutável — &mut (só uma por vez) fn adicionar(s: &mut String) { s.push_str(", mundo"); } let mut s = String::from("Olá"); adicionar(&mut s); 📏 Regras do Borrow Checker ✅ Múltiplas & imutáveis simultâneas são OK ✅ Uma &mut exclusiva é OK ❌ & + &mut ao mesmo tempo = ERRO ❌ Referência não pode viver mais que o dono 💡 O Borrow Checker previne data races e use-after-free em compile-time — zero custo em runtime!
9. Structs & Enums Como modelar dados em Rust (sem classes!) // Struct — como uma classe sem herança #[derive(Debug)] struct Usuario { nome: String, email: String, ativo: bool, } impl Usuario { fn new(nome: String, email: String) -> Self { Self { nome, email, ativo: true } } } let u = Usuario::new("Alice".into(), "a@b.com".into()); // Enum com dados (Algebraic Data Type) enum Forma { Circulo { raio: f64 }, Retangulo { larg: f64, alt: f64 }, } impl Forma { fn area(&self) -> f64 { match self { Forma::Circulo { raio } => std::f64::consts::PI * raio * raio, Forma::Retangulo { larg, alt } => larg * alt, } } } 💡 Enums em Rust são muito mais poderosos que em Java — carregam dados e são processados com match exaustivo.
10. Option<T> & Result<T,E> — Adeus NullPointerException! Tratamento de erros idiomático em Rust // Option — valor presente ou ausente (sem null!) fn buscar_usuario(id: u32) -> Option<String> { if id == 1 { Some("Alice".to_string()) } else { None } } match buscar_usuario(1) { Some(nome) => println!("Usuário: {}", nome), None => println!("Não encontrado"), } // Atalho: if let if let Some(nome) = buscar_usuario(1) { println!("Olá, {nome}"); } // Result — sucesso ou erro (sem try/catch!) use std::num::ParseIntError; fn parsear(s: &str) -> Result<i32, ParseIntError> { s.trim().parse::<i32>() } match parsear("42") { Ok(n) => println!("Número: {n}"), Err(e) => eprintln!("Erro: {e}"), } // ? operator — propaga erros (equivale a unwrap + return Err) fn run() -> Result<(), Box<dyn std::error::Error>> { let n = parsear("99")?; // ? propaga o Err Ok(()) } 🔑 Option e Result são enums! O compilador obriga a tratar ambos os casos — chega de NPE silenciosos.
11. Pattern Matching — match, if let, while let O switch/case evoluído do Rust // match é exaustivo — todos os casos obrigatórios let nota = 85; let conceito = match nota { 90..=100 => "A", // range inclusivo 70..=89 => "B", 50..=69 => "C", _ => "F", // _ = wildcard }; // match em enums com destructuring enum Mensagem { Mover { x: i32, y: i32 }, Sair, Escrever(String) } match msg { Mensagem::Mover { x, y } => println!("Move ({x}, {y})"), Mensagem::Escrever(texto) => println!("{texto}"), Mensagem::Sair => return, } // Guards — condição extra no match let num = 7; match num { x if x < 0 => println! ("negativo"), x if x == 0 => println!("zero"), _ => println! ("positivo"), } // while let — loop até o padrão falhar let mut pilha = vec![1,2,3]; while let Some(topo) = pilha.pop() { println!("{topo}"); } 🔑 match em Rust é uma expressão — retorna valor! Diferente do switch em Java/Go.
12. Traits — As Interfaces do Rust Polimorfismo sem herança de classes // Trait — como interface em Java / Go trait Area { fn area(&self) -> f64; // método abstrato fn descricao(&self) -> String { // método com default format!("Área = {:.2}", self.area()) } } struct Circulo { raio: f64 } impl Area for Circulo { fn area(&self) -> f64 { std::f64::consts::PI * self.raio.powi(2) } } // Generics com trait bounds fn imprimir_area<T: Area>(forma: &T) { println!("{}", forma.descricao()); } // Traits úteis da std::lib // Display, Debug, Clone, Copy // Iterator, From/Into, Default // PartialEq, Ord, Hash // derive macro — implementação automática #[derive(Debug, Clone, PartialEq)] struct Ponto { x: f64, y: f64 } 📌 Rust não tem herança de classes — composição com traits é o caminho. Mais flexível, sem diamond problem!
13. Closures & Iterators Programação funcional de alta performance // Closure — função anônima que captura contexto let dobrar = |x| x * 2; let somar = |a, b: i32| a + b; // Closures capturam o ambiente let fator = 3; let multiplicar = |x| x * fator; // captura fator // Iterator — zero-cost, lazy let nums = vec![1,2,3,4,5]; let resultado: Vec<_> = nums .iter() .filter(|&&x| x % 2 == 0) // [2, 4] .map(|&x| x * x) // [4, 16] .collect(); // resultado = [4, 16] // sum, count, fold, any, all let soma: i32 = (1..=10).sum(); // 55 let max = nums.iter().max(); // Some(5) // chain, zip, enumerate, flat_map let pares: Vec<_> = [1,2] .iter() .zip(["a", "b"].iter()) .collect(); // [(1,'a'),(2,'b')] // Iterators são LAZY — só executam no collect() // Sem alocação intermediária = zero- cost! ⚡ Iterator chains em Rust são compilados para loops otimizados — mesma performance que código imperativo manual.
14. Lifetimes — Tempo de Vida de Referências Como o compilador garante referências válidas O que são Lifetimes? // Lifetime annotation: 'a // Garante que a ref retornada vive tanto quanto as entradas fn maior<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } } // Lifetime elision — o compilador infere em casos simples fn primeiro_palavra(s: &str) -> &str { let bytes = s.as_bytes(); for (i, &byte) in bytes.iter().enumerate() { if byte == b' ' { return &s[0..i]; } } s // sem &mut s — borrow ok } 🧩 Analogia Lifetime 'static A referência vive por toda a execução do programa (e.g. string literals) Lifetime 'a (genérico) O compilador rastreia que ref de saída é tão velha quanto a entrada Lifetime elision Na maioria dos casos, não precisa escrever 'a o compilador deduz 💡 Na prática: a maioria do código Rust não escreve lifetimes explícitos — o compilador resolve automaticamente.
15. Concorrência — Fearless Concurrency Threads, Arc<Mutex<T>> e async/await // Threads — como Java, mas com ownership use std::thread; use std::sync::{Arc, Mutex}; let contador = Arc::new(Mutex::new(0)); let mut handles = vec![]; for _ in 0..10 { let c = Arc::clone(&contador); handles.push(thread::spawn(move || { let mut num = c.lock().unwrap(); *num += 1; })); } for h in handles { h.join().unwrap(); } // *contador.lock().unwrap() == 10 ✅ // async/await com Tokio (1.x) // Cargo.toml: tokio = { features=["full"] } #[tokio::main] async fn main() { let r1 = buscar_url("url1"); let r2 = buscar_url("url2"); // executa em paralelo! let (a, b) = tokio::join!(r1, r2); } async fn buscar_url(url: &str) -> String { // ... } 🛡️ Data races são impossíveis em Rust — Arc<Mutex<T>> garante que o compilador impeça acesso inseguro.
16. Crates Essenciais do Ecossistema As bibliotecas que você vai usar no dia a dia serde / serde_json v1.0 Serialização JSON, YAML, TOML. O mais baixado do crates.io tokio v1.x Async Runtime Runtime assíncrono padrão. Base do ecossistema async reqwest v0.12 HTTP Client Cliente HTTP com async, baseado em tokio + hyper axum v0.8 Web Framework Framework web ergonômico da equipe do tokio sqlx v0.8 Database SQL async com checagem em compile- time. Postgres/SQLite anyhow / thiserror v1.x Error Handling anyhow: erros simples. thiserror: tipos de erro clap v4.x CLI Parser de argumentos CLI com derive macros rayon v1.x Paralelismo Paralelismo de dados com iterators paralelos tracing v0.1 Observability Logs estruturados e tracing distribuído 📦 crates.io — repositório central de pacotes Rust • lib.rs — busca avançada de crates
17. Testes — Integrado ao Cargo Unit tests, integration tests e doc tests // Testes unitários — mesmo arquivo, módulo #[cfg(test)] pub fn somar(a: i32, b: i32) -> i32 { a + b } #[cfg(test)] mod tests { use super::*; #[test] fn test_somar() { assert_eq!(somar(2, 3), 5); } #[test] #[should_panic(expected = "divisão por zero")] fn test_panic() { dividir(1, 0); } } // Doc tests — exemplos na documentação testados! /// Soma dois números. /// /// # Exemplos /// /// ``` /// assert_eq!(minha_lib::somar(2, 3), 5); /// ``` pub fn somar(a: i32, b: i32) -> i32 { a + b } // Comandos de teste // cargo test — todos os testes // cargo test test_somar — filtrar por nome // cargo test -- --nocapture — ver println! ✅ test result: ok. 3 passed; 0 failed; 0 ignored running 3 tests ... ok 🧪 Testes em Rust são cidadãos de primeira classe — compilados junto ao código, sem framework externo.
18. Novidades do Rust 1.94.0 — 5 de Março de 2026 As features reais estabilizadas nesta versão 🆕 Biblioteca Padrão  array_windows — janelas de tamanho fixo em slices  LazyCell::get e LazyLock::get estabilizados  Peekable::next_if_map — consumir e transformar  element_offset — índice de elemento em slice  BinaryHeap: bound T: Ord relaxado 📦 Cargo & Toolchain  config include: divide Cargo.toml em arquivos  pubtime: data de publicação no registry  Suporte a TOML v1.1 em manifests e configs  annotate-snippets: mensagens de erro melhores 🔧 Linguagem  impls herdam dead_code lint do dados = &[1, 2, 3, 4, 5, 6];pai  Closures: captura mais precisa de variáveis  Lifetimes NFC normalizados  29 target features RISC-V estabilizadas  Lint para visibilidade em const _ declarations // array_windows — janelas de tamanho fixo (novidade 1.94) let dados = &[10, 20, 30, 40, 50]; for [a, b, c] in dados.array_windows() { println!("{a} + {b} + {c} = {}", a + b + c); } // Saída: 10+20+30=60 20+30+40=90 30+40+50=120 // LazyLock::get — verifica inicialização sem forçar static CACHE: LazyLock<Config> = LazyLock::new(Config::load); if let Some(cfg) = CACHE.get() { cfg.use_it() }
19. Roadmap de Estudos — Java/Go Rust → Plano de aprendizado progressivo para desenvolvedores Fase 1 Semanas 1-2 Fundamentos → Variables, types, control flow → Ownership & borrowing (core!) → Structs, enums, impl → Cargo básico Fase 2 Semanas 3-4 Intermediário → Traits & generics → Error handling (Result/Option) → Closures & iterators → Lifetimes básicos Fase 3 Semanas 5-6 Avançado → Concorrência & async/await → Smart pointers (Box, Rc, Arc) → Unsafe Rust (básico) → Macros declarativas Fase 4 Semana 7+ Projetos Reais → API REST com Axum → CLI com clap → Web scraping com reqwest → Contribuição open source
20. Referências & Recursos 📚 Livros & Docs Oficiais  The Rust Programming Language ("The Book") — doc.rust- lang.org/book  Rust Reference — doc.rust-lang.org/reference  Rust by Example — doc.rust-lang.org/rust-by-example  Rustonomicon (unsafe) — doc.rust-lang.org/nomicon 🎯 Exercícios Interativos  Rustlings — github.com/rust-lang/rustlings (pequenos exercícios)  Exercism (Rust track) — exercism.org/tracks/rust  Advent of Code com Rust — adventofcode.com 📺 Vídeos & Cursos  Jon Gjengset — YouTube: Crust of Rust series (avançado, excelente)  Let's Get Rusty — YouTube: série para iniciantes  Zero To Production in Rust — livro prático de web dev 🌐 Comunidade  users.rust-lang.org — fórum oficial  r/rust — reddit.com/r/rust  Rust Discord — discord.gg/rust-lang-community  This Week in Rust — this-week-in-rust.org (newsletter) 🦀 Rust 1.94.0 (Mar 2025) • rust-lang.org • crates.io • play.rust-lang.org