
Rust surgiu em 2010 nos laboratórios da Mozilla com um objetivo ambicioso: criar uma linguagem de sistemas tão rápida quanto C/C++, mas sem os vulnerabilidades de memória que causam a maioria das falhas de segurança em software. Em 2024, Rust foi oficialmente adicionada ao kernel Linux. Grandes empresas como AWS, Google, Microsoft e Meta investem massivamente em Rust para serviços críticos. A curva de aprendizado é íngreme, mas os benefícios compensam o investimento.
O problema que Rust resolve
Em C e C++, o programador gerencia memória manualmente. Esquecer de liberar memória causa vazamentos (memory leaks). Liberar cedo demais ou acessar ponteiros inválidos causa use-after-free, double-free e buffer overflows. Esses bugs representam aproximadamente 70% das vulnerabilidades de segurança em software de sistema, segundo levantamentos publicados pela Microsoft (sobre seus próprios produtos) e pelo projeto Chromium (links nas fontes).
Rust elimina esses problemas em tempo de compilação, sem garbage collector. O compilador impede que código inseguro compile, tornando certas categorias de bugs impossíveis de existir no binário final.
Ownership: o conceito central
O sistema de ownership do Rust é baseado em regras simples: cada valor tem um único dono (owner); quando o dono sai de escopo, o valor é automaticamente liberado; e a propriedade pode ser transferida (moved), mas nunca compartilhada implicitamente. Isso elimina a necessidade de garbage collector enquanto previne vazamentos.
fn main() {
let s1 = String::from("hello");
let s2 = s1; // move: s1 não é mais válido
// println!("{}", s1); // ERRO: value borrowed here after move
println!("{}", s2); // ok
}Esse exemplo parece estranho para quem vem de JavaScript ou Python, onde atribuições copiam referências. Em Rust, a atribuição de String transfere ownership. O compilador rejeita o uso de s1 após a transferência, prevenindo use-after-free.
Borrowing e lifetimes
Borrowing permite acessar dados sem tomar posse deles. Referências imutáveis (&T) permitem múltiplos leitores. Referências mutáveis (&mut T) exigem exclusividade: apenas um mut borrow por vez. Essa regra previne data races em tempo de compilação.
fn len(s: &String) -> usize {
s.len() // borrowing imutável: não toma posse
}
fn main() {
let s = String::from("hello");
println!("{}", len(&s));
println!("{}", s); // ainda válido — ownership não foi transferido
}Lifetimes são anotações que ajudam o compilador a garantir que referências nunca apontem para dados inválidos. Embora sintam-se intimidadoras no início, lifetimes são inferidas automaticamente na maioria dos casos. Você as escreve explicitamente apenas em funções genéricas complexas.
Cargo: gerenciamento de projetos
Cargo é a ferramenta de build e gerenciamento de dependências do Rust. Equivale a npm + webpack em um único binário. cargo new cria projetos, cargo build compila, cargo test executa testes, cargo run roda o binário. O registro crates.io hospeda mais de 150 mil pacotes. A curva de aprendizado de Cargo é mínima; a dificuldade está na linguagem em si.
Quando usar Rust
- Sistemas embarcados e firmware onde C domina, mas segurança é crítica.
- Servidores de alta performance que precisam de latência previsível (sem GC pauses).
- WebAssembly para computação pesada no browser.
- Ferramentas CLI que precisam ser rápidas e portáveis.
- Sistemas operacionais, hipervisores e drivers de dispositivo.
Quando NÃO usar Rust
- Prototipagem rápida: Python, JavaScript e Go entregam resultados mais rápido.
- Aplicações com grande base de código legada em outra linguagem — migração é custosa.
- Equipes sem tempo para treinamento: Rust exige semanas de prática antes de produtividade plena.
Recursos para começar
O livro oficial "The Rust Programming Language" (disponível gratuitamente em rust-book.cs.brown.edu) é o melhor ponto de partida. A linguagem é ensinada diretamente pelos criadores, com exercícios progressivos. Rustlings é uma coleção de exercícios práticos que ensina corrigindo erros de compilação reais. Exercism oferece uma trilha de Rust com mentorias.
Tratamento de erros com Result e o operador ?
Rust não tem exceções. Uma função que pode falhar devolve Result<T, E>: Ok com o valor ou Err com o erro. O compilador obriga quem chama a lidar com os dois casos. O operador ? encurta o caminho: se o resultado for Err, a função retorna o erro imediatamente, convertendo-o pelo trait From quando necessário.
use std::fs;
use std::num::ParseIntError;
#[derive(Debug)]
enum ConfigError {
Io(std::io::Error),
Parse(ParseIntError),
}
impl From<std::io::Error> for ConfigError {
fn from(e: std::io::Error) -> Self { ConfigError::Io(e) }
}
impl From<ParseIntError> for ConfigError {
fn from(e: ParseIntError) -> Self { ConfigError::Parse(e) }
}
fn ler_porta(caminho: &str) -> Result<u16, ConfigError> {
let texto = fs::read_to_string(caminho)?;
let porta: u16 = texto.trim().parse()?;
Ok(porta)
}
fn main() {
match ler_porta("porta.txt") {
Ok(p) => println!("porta: {p}"),
Err(e) => eprintln!("erro de configuração: {e:?}"),
}
}Para ausência de valor (e não erro), o tipo é Option<T>, com Some e None. Em protótipos, unwrap() encerra o programa se der errado; em código de produção, prefira propagar com ? ou tratar com match. Na prática, muitos projetos usam as crates thiserror (para definir erros de bibliotecas) e anyhow (para aplicações) em vez de escrever as conversões à mão.
Erros de compilação mais comuns de quem começa
O compilador de Rust é conhecido por mensagens detalhadas. Cada erro tem um código, e rustc --explain E0382 mostra uma explicação completa com exemplos. Estes são os que mais aparecem nas primeiras semanas:
| Código | Mensagem (resumida) | O que aconteceu | Saída típica |
|---|---|---|---|
| E0382 | use of moved value | A variável foi usada depois de ter a posse transferida | Passar uma referência (&valor) ou clonar com .clone() |
| E0499 | cannot borrow as mutable more than once | Duas referências mutáveis ao mesmo dado ao mesmo tempo | Encerrar o primeiro empréstimo antes de criar o segundo |
| E0502 | cannot borrow as mutable because it is also borrowed as immutable | Ler e alterar ao mesmo tempo, como dar push num vetor enquanto o percorre | Coletar o que precisa mudar e alterar depois do laço |
| E0106 | missing lifetime specifier | Função retorna referência sem indicar de qual entrada ela vem | Retornar um valor próprio (String) ou anotar o lifetime |
Esses erros não são obstáculos arbitrários: cada um corresponde a uma classe de bug (uso após liberação, condição de corrida) que em C ou C++ só apareceria em produção.
Conclusão
Rust não é uma linguagem para todos os cenários, mas é indispensável quando performance e segurança de memória são não-negociáveis. A curva de aprendizado é real — o compilador será seu professor mais exigente — mas cada erro que ele aponta é um bug que não chegará à produção. Para quem trabalha com sistemas críticos ou busca diferenciação no mercado, investir em Rust é decisão estratégica.
Perguntas frequentes
+Rust é mais rápido que C++?
Em benchmarks teóricos, os resultados são comparáveis. A vantagem de Rust está na segurança de memória sem perda de performance, não necessariamente em velocidade bruta superior.
+Preciso aprender C antes de Rust?
Não. Na verdade, quem nunca programou em C pode achar Rust mais natural, pois não precisa 'desaprender' hábitos inseguros de ponteiros.
+Rust tem garbage collector?
Não. A memória é gerenciada pelo sistema de ownership em tempo de compilação. Não há pausas de GC em runtime.
+É possível usar Rust para web backend?
Sim. Frameworks como Actix-web, Axum e Rocket permitem construir APIs e servidores HTTP em Rust com performance excepcional.
Fontes consultadas
- Microsoft Security Response Center — A proactive approach to more secure code
- The Chromium Projects — Memory safety
- The Rust Programming Language Book
- Rustlings — Exercícios Interativos
- Cargo Book
Histórico: publicado em ; atualizado em . Conteúdo educativo, sem patrocínio das ferramentas citadas. Encontrou um erro? Envie uma correção.
Leia também

Expressões regulares na prática: guia com exemplos em JavaScript e Python
O que são expressões regulares, a sintaxe essencial em uma tabela, exemplos testáveis em JavaScript e Python (datas, CEP, logs), diferença entre ganancioso e preguiçoso e como evitar ReDoS.

Cache em aplicações web: HTTP, CDN e Redis — onde guardar cada dado
Como funcionam as camadas de cache de uma aplicação web, quais cabeçalhos Cache-Control usar para cada tipo de recurso, o padrão cache-aside com Redis e como evitar dados velhos e vazamentos.

Serverless: quando funções serverless valem a pena (e quando viram armadilha)
AWS Lambda, Cloudflare Workers e Vercel Functions comparados: modelo de custo, cold starts, limites de execução e os workloads onde serverless brilha ou falha.