Rust: a linguagem que resolve o problema de memória sem coletor de lixo

• O que é Rust e qual problema ela resolve?
• Como funcionam ownership e o borrow checker?
• Rust vs C++ vs Go: quando escolher cada uma?
• Onde Rust já é usado em produção?
• Quais são as desvantagens reais de Rust?
• Como começar a aprender Rust?

Rust responde a um dilema antigo: até ela, dava para ter velocidade de execução ou segurança de memória, não os dois. A linguagem move a verificação para o tempo de compilação e entrega binários rápidos sem coletor de lixo e sem as falhas clássicas de C.

O que é Rust e qual problema ela resolve?

Rust é uma linguagem compilada de propósito geral, criada na Mozilla por Graydon Hoare e estabilizada em 2015. Seu objetivo declarado é permitir programação de sistemas — a camada onde vivem sistemas operacionais, bancos de dados e navegadores — sem pagar o preço histórico dessa camada: bugs de memória.

O problema é mensurável. Microsoft e Google reportaram, em análises independentes de suas próprias bases de código, que cerca de 70% das vulnerabilidades de segurança graves têm origem em falhas de gestão de memória — leitura fora dos limites, uso após liberação, ponteiro nulo. São erros que linguagens como C e C++ permitem por design e que dependem inteiramente da disciplina de quem escreve.

As linguagens com coletor de lixo — Java, Go, C#, Python — resolvem isso terceirizando a memória para um processo em tempo de execução. Funciona, mas custa: pausas imprevisíveis, consumo maior de RAM e uma camada a menos de controle. Para um serviço web comum, ótimo negócio; para um driver, um kernel ou um motor de renderização, inaceitável.

Rust escolhe um terceiro caminho: provar na compilação que o programa não comete esses erros. Se a prova falha, o binário não é gerado.

Exemplo prático: em C, devolver um ponteiro para uma variável local é um erro que compila, roda e falha de forma aleatória meses depois. Em Rust, o compilador identifica que a referência viveria mais que o dado e recusa a compilação com a explicação do porquê.

Como funcionam ownership e o borrow checker?

Três regras sustentam todo o modelo de memória:

1. Cada valor tem exatamente um dono.
2. Só pode haver um dono por vez — atribuir a outra variável move a posse.
3. Quando o dono sai de escopo, o valor é descartado e a memória liberada.

Para usar um valor sem transferir a posse, você o empresta por referência. E aí entra a regra que causa a fama de linguagem difícil: em um dado momento você pode ter ou várias referências imutáveis, ou uma única referência mutável. Nunca as duas coisas.

fn main() {
    let nome = String::from("CodeCrush");
    let tamanho = calcular(&nome);       // empréstimo imutável
    println!("{} tem {} caracteres", nome, tamanho); // nome ainda é válido

    let mut lista = vec![1, 2, 3];
    let primeiro = &lista[0];            // empréstimo imutável
    // lista.push(4);                    // ERRO: empréstimo mutável enquanto há imutável
    println!("primeiro = {}", primeiro);
}

fn calcular(texto: &str) -> usize {
    texto.len()
}

Essa restrição parece burocrática até você perceber o que ela compra: se apenas uma referência mutável existe por vez, corrida de dados entre threads é impossível por construção. Não é convenção nem boa prática — é uma propriedade verificada pelo compilador. É por isso que a comunidade fala em fearless concurrency: paralelizar em Rust não traz a ansiedade de descobrir um bug de concorrência em produção.

Exemplo prático: o Firefox reescreveu o motor de CSS em Rust (projeto Stylo) justamente para paralelizar o cálculo de estilos. Tentativas anteriores em C++ foram abandonadas pelo risco de corridas; com o borrow checker, a paralelização foi verificada em compilação.

Rust vs C++ vs Go: quando escolher cada uma?

As três disputam espaço em sistemas e infraestrutura, com trade-offs distintos:

A escolha fica clara quando você define a prioridade. Se o requisito é latência previsível com segurança — trading, drivers, banco de dados, embarcados —, Rust. Se o requisito é produtividade em serviços de rede, Go entrega mais código útil por hora. Se o requisito é integrar com um ecossistema existente de décadas — engines de jogos, computação científica, CUDA —, C++ continua imbatível.

Exemplo prático: o Discord migrou um serviço de estado de leitura de Go para Rust em 2020 e documentou o motivo: as pausas do coletor de lixo criavam picos de latência a cada dois minutos. Em Rust, sem GC, os picos desapareceram e o consumo de memória caiu.

Onde Rust já é usado em produção?

A adoção saiu do nicho e entrou na infraestrutura que sustenta a web:

1. Sistemas operacionais. Rust foi aceita no kernel do Linux a partir da versão 6.1 (2022) para escrita de drivers, e a Microsoft reescreveu componentes do Windows — incluindo partes da fonte gráfica no kernel — em Rust.
2. Infraestrutura de nuvem. A AWS usa Rust no Firecracker, o hipervisor por trás do Lambda e do Fargate. A Cloudflare escreveu o Pingora, o proxy que substituiu o NGINX em boa parte de sua rede.
3. Ferramentas de desenvolvimento. Grande parte da nova geração de ferramentas de JavaScript é Rust por baixo: SWC, Turbopack, Rspack, Biome e o gerenciador de pacotes uv para Python.
4. WebAssembly. Rust é a linguagem com melhor suporte a Wasm, permitindo rodar código de alta performance no navegador — de editores de vídeo a engines de jogos.
5. Embarcados e IoT. O suporte a no_std permite usar Rust em microcontroladores, um espaço historicamente exclusivo de C — relevante para quem trabalha com sistemas embarcados.

O denominador comum: contextos em que uma falha de memória é cara demais, seja em segurança, seja em disponibilidade.

Exemplo prático: o Android incorporou Rust em componentes novos a partir de 2021. O Google reportou que, entre 2019 e 2024, a proporção de vulnerabilidades de memória no sistema caiu de 76% para 24% — sem reescrever o código antigo, apenas escrevendo o novo em linguagens seguras.

Quais são as desvantagens reais de Rust?

Quatro custos aparecem consistentemente em relatos de adoção:

1. Curva de aprendizado íngreme. O borrow checker recusa padrões que funcionam em outras linguagens — listas duplamente encadeadas, grafos com ciclos, referências circulares — e exige aprender ferramentas específicas (Rc, RefCell, tempos de vida explícitos) para expressá-los. Os primeiros meses são de baixa produtividade.
2. Tempo de compilação. Projetos grandes compilam devagar. Existe mitigação (compilação incremental, cargo check, linkers alternativos), mas o atrito é real no ciclo de desenvolvimento.
3. Ecossistema mais novo. O crates.io tem mais de 190 mil pacotes, porém em domínios específicos — computação científica, machine learning, integração com sistemas legados corporativos — o catálogo ainda perde para Python, Java e C++.
4. Mercado de trabalho menor. Há demanda, geralmente bem paga e concentrada em infraestrutura, blockchain e sistemas críticos. Mas o volume de vagas está longe do de JavaScript ou Java, o que importa para quem está escolhendo a primeira linguagem de programação.

Exemplo prático: um time acostumado a Python estimou duas semanas para portar um serviço de processamento de arquivos para Rust. Levou seis — quatro delas discutindo com o compilador sobre tempos de vida. O serviço final ficou 40 vezes mais rápido, mas a estimativa inicial ignorou o custo de aprendizado.

Como começar a aprender Rust?

Um caminho eficiente, na ordem que economiza frustração:

1. Instale com rustup e use o Cargo desde o primeiro dia. O cargo cuida de build, dependências, testes e formatação — a experiência de ferramental é um dos pontos fortes da linguagem.
2. Leia o "The Rust Programming Language" (o Book). É gratuito, oficial e provavelmente o melhor livro introdutório de qualquer linguagem. Faça os exercícios do capítulo 4 (ownership) com calma; tudo depende dele.
3. Pratique com Rustlings. Pequenos exercícios que compilam com erro e pedem correção. Ensina a ler as mensagens do compilador, que são excepcionalmente boas e explicam a causa, não só o sintoma.
4. Escreva uma CLI de verdade. Uma ferramenta que você usaria — renomear arquivos em lote, parsear logs. Com as crates clap e serde, o resultado é útil e o escopo é pequeno.
5. Só então enfrente concorrência e async. tokio, async/await e traits avançadas fazem muito mais sentido depois que ownership virou intuição.

Uma dica que muda a experiência: trate os erros do compilador como revisão de código, não como obstáculo. Quase sempre a mensagem descreve exatamente o problema conceitual e sugere a correção — e a lição costuma valer para o código que você escreve em qualquer outra linguagem.

Exemplo prático: um desenvolvedor que trocou o "vou ler o livro inteiro antes de codar" por "leio um capítulo e aplico numa CLI" chegou a código útil na segunda semana. A ordem importa mais que o volume de estudo.

Conclusão

Rust não é uma linguagem melhor em tudo — é uma linguagem que faz uma troca específica e explícita: mais esforço na escrita para eliminar, por construção, uma classe inteira de falhas que custa caro em produção. Onde essa troca compensa — sistemas operacionais, infraestrutura de rede, bancos de dados, embarcados, ferramentas de alta performance —, ela já venceu a discussão, e a presença no kernel do Linux, no Windows e na base da AWS é a evidência. Onde não compensa — CRUDs, protótipos, scripts, produtos ainda buscando encaixe de mercado —, insistir em Rust é pagar um custo sem receber o benefício. Se você trabalha perto do metal ou quer entender de verdade como memória funciona, o investimento de dois a três meses até a fluência se paga; e o entendimento que o borrow checker força fica com você mesmo quando volta para outra linguagem.