Toda linguagem de programação nasce de uma frustração. C nasceu da necessidade de escrever Unix sem assembly. Python nasceu do desejo de tornar o código legível como prosa. E Rust? Rust nasceu do cansaço de ver sistemas travarem, crasharem e serem invadidos por causa de erros de memória que compiladores simplesmente ignoravam.
Em 2006, um engenheiro da Mozilla chamado Graydon Hoare começou Rust como um projeto pessoal. Ele estava cansado de ver elevadores — sim, elevadores — com software embutido que travava e precisava ser reiniciado manualmente. A pergunta que ele se fez foi simples e devastadora: por que ainda aceitamos que software confiável seja difícil de escrever?
A Mozilla passou a patrocinar o projeto em 2009, e em 2015 foi lançada a versão estável 1.0. Desde então, Rust foi eleito a linguagem "mais amada" pelos desenvolvedores por nove anos consecutivos na pesquisa anual do Stack Overflow (2016–2024) — um feito sem precedentes na história da pesquisa.
O Problema que Rust resolve
Durante décadas, os programadores viveram num dilema cruel.
Você podia escrever em C ou C++ e ter desempenho máximo — mas pagar o preço com bugs de memória difíceis de encontrar: ponteiros nulos, uso de memória já liberada, condições de corrida em código paralelo. Esses bugs não são apenas inconvenientes. Segundo um relatório interno da Microsoft de 2019, aproximadamente 70% das vulnerabilidades de segurança nos produtos da empresa eram causadas por erros de gerenciamento de memória. O Google reportou número semelhante para o Chrome, também em 2019, no blog do Project Zero.
Ou você podia escrever em linguagens gerenciadas — Java, Python, Go — e ganhar segurança automática, mas abrir mão de controle e desempenho, carregando o peso de um coletor de lixo que pode pausar seu programa nos momentos mais críticos.
Rust recusou esse dilema. Sua proposta central é: segurança de memória sem coletor de lixo, com desempenho equivalente ao C.
Tanto é que em 2022, a Casa Branca publicou um relatório oficial — o "Back to the Building Blocks" — recomendando o uso de linguagens memory-safe como Rust para o desenvolvimento de software crítico nos Estados Unidos. A NSA fez recomendação semelhante em 2022, citando Rust pelo nome.
Como Rust resolve isso?
A resposta está em um sistema chamado ownership — propriedade. É o coração de tudo em Rust, e é o que vai ocupar boa parte da nossa jornada juntos.
A ideia central é elegante: cada valor na memória tem exatamente um dono. Quando o dono sai de cena, o valor é destruído automaticamente. Sem coletor de lixo. Sem ponteiros pendurados no ar. O compilador verifica tudo isso antes do programa sequer rodar.
Isso significa que uma classe inteira de erros simplesmente não existe em Rust. O compilador os mata na compilação. Você vai brigar com o compilador no início — todos brigam. Mas com o tempo vai entender que ele é o seu melhor aliado.
Instalando o Rust
O método oficial e recomendado para instalar Rust em qualquer sistema operacional é através do rustup, um gerenciador de versões e toolchain da linguagem. Ele instala o compilador (rustc), o gerenciador de pacotes (cargo) e mantém tudo atualizado com um único comando.
No Linux e macOS
Abra o terminal e execute:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
O script vai guiar você pela instalação interativa. Ao final, ele pedirá para você reiniciar o terminal ou executar:
source $HOME/.cargo/env
Feito isso, verifique a instalação com:
rustc --version
cargo --version
No Windows
No Windows, acesse https://rustup.rs pelo navegador e baixe o instalador rustup-init.exe. Execute-o como qualquer programa. Uma janela de terminal vai abrir com as opções de instalação — na maioria dos casos, basta pressionar 1 para aceitar a instalação padrão.
Atenção: O Rust no Windows depende das ferramentas de compilação do Microsoft C++ Build Tools. Se você não as tiver instaladas, o rustup vai indicar como baixá-las. A forma mais simples é instalar o Visual Studio Build Tools 2022 (gratuito), marcando a opção "Desktop development with C++" durante a instalação.
Após concluir, abra um novo Prompt de Comando ou PowerShell e verifique:
rustc --version
cargo --version
Se ambos retornarem versões, você está pronto.
Configurando o editor
Recomendo o Visual Studio Code com a extensão rust-analyzer. Ela oferece autocompletar, verificação de erros em tempo real, e dicas inline do compilador diretamente no editor — algo especialmente valioso quando você estiver aprendendo as regras de ownership. Instale pelo marketplace do VS Code pesquisando por "rust-analyzer".
Seu primeiro programa em Rust
Com tudo instalado, crie um arquivo chamado main.rs e escreva:
fn main() {
println!("Olá, Rust. Vamos até o fim.");
}
Compile e execute:
rustc main.rs
./main # Linux/macOS
.\main.exe # Windows
Dois detalhes que já carregam a filosofia da linguagem merecem atenção: fn é a palavra-chave para funções, e println! — aquele ponto de exclamação — não é erro de digitação. Ele indica que isso é uma macro, não uma função comum. Rust distingue os dois explicitamente. Você vai entender por quê mais adiante.
O que esperar desses artigos
Ao longo dos próximos artigos, vamos construir conhecimento de forma progressiva. Não existe atalho para dominar Rust — mas existe um caminho inteligente.
Nos primeiros meses, vamos entender ownership, borrowing e lifetimes. Conceitos que não existem em outras linguagens e que vão exigir uma mudança genuína na forma como você pensa sobre memória.
Depois, vamos explorar o sistema de tipos de Rust: enums com dados, traits como interfaces flexíveis, e tratamento de erros sem exceções. Na segunda metade do ano, entraremos em programação concorrente segura, macros, performance e projetos reais.
Exercícios
Exercício 1
Rust não tem coletor de lixo e mesmo assim não exige free. Explique, em duas ou três frases, como as duas coisas convivem, e diga em que momento a memória é efetivamente liberada.
Ver resposta
✓ Resposta: Rust decide em tempo de compilação onde cada valor deixa de ser necessário e insere a liberação nesse ponto. Isso é possível porque todo valor tem um dono único, e quando o dono sai de escopo o valor é descartado — sem contador em tempo de execução, como faria um coletor de lixo, e sem depender de o programador lembrar. A liberação acontece no fim do escopo do dono, de forma determinística: o mesmo programa libera sempre no mesmo ponto.
Exercício 2
Preveja a saída e depois explique o que o cargo run faz além de executar o programa:
fn main() {
let nome = "mundo";
println!("Olá, {nome}!");
}
Ver resposta
✓ Resposta: A saída é Olá, mundo!. A interpolação {nome} dentro da string funciona desde o Rust 1.58; em versões anteriores seria println!("Olá, {}!", nome). O cargo run faz mais que executar: ele verifica se o código mudou desde a última vez, compila o que for preciso (resolvendo e compilando também as dependências declaradas no Cargo.toml), coloca o binário em target/debug/ e só então o executa.
Exercício 3
O programa abaixo não compila. Sem consultar o compilador, diga por quê e corrija.
fn main() {
let contador = 0;
contador = contador + 1;
println!("{contador}");
}
Ver resposta
✓ Resposta: Em Rust, let cria um vínculo imutável por padrão, então a segunda linha tenta atribuir a algo que não pode mudar e o compilador recusa com cannot assign twice to immutable variable. A correção é declarar a mutabilidade explicitamente:
fn main() {
let mut contador = 0;
contador = contador + 1;
println!("{contador}");
}
Vale notar a inversão em relação a C e Python: ali tudo é mutável e a imutabilidade é que precisa ser pedida.
Exercício 4
Escreva um programa que declare seu nome e sua idade em variáveis separadas e imprima uma frase usando as duas. Depois, explique por que Rust exige anotar o tipo em alguns casos e em outros não.
Ver resposta
✓ Resposta: Uma versão possível:
fn main() {
let nome = "Ana";
let idade = 34;
println!("{nome} tem {idade} anos.");
}
Rust tem inferência de tipos: quando consegue deduzir o tipo a partir do valor ou do uso, a anotação é dispensável — aqui deduz &str e i32. A anotação passa a ser obrigatória quando a inferência é ambígua, como em let n: u64 = "42".parse().unwrap();, em que só o tipo declarado diz em que converter. Inferir não é ser dinâmico: o tipo continua fixo e verificado em tempo de compilação.
Exercício 5
Um colega afirma: "Rust é seguro porque proíbe ponteiros". A afirmação está errada em mais de um ponto. Corrija-a, dizendo o que Rust de fato proíbe e o que ele permite.
Ver resposta
✓ Resposta: Rust não proíbe ponteiros: referências (&T e &mut T) são ponteiros, e existem ainda os ponteiros crus (*const T e *mut T). O que o compilador proíbe, no código seguro, é o uso inválido deles — referência que sobrevive ao dado apontado, dois caminhos de escrita simultâneos para a mesma posição, leitura de memória já liberada. Os ponteiros crus continuam disponíveis dentro de blocos unsafe, onde a verificação é suspensa e a responsabilidade passa a ser de quem escreve. A garantia, portanto, não é "não há ponteiro", e sim "fora de unsafe, o compilador provou que estes usos são válidos".
Fontes e leituras recomendadas
- The Rust Programming Language — Steve Klabnik e Carol Nichols. O livro oficial, gratuito online em https://doc.rust-lang.org/book/. É a referência primária desta série.
- Stack Overflow Developer Survey 2024 — https://survey.stackoverflow.co/2024 — dados sobre a popularidade e adoção do Rust.
- Microsoft Security Response Center, 2019 — "A proactive approach to more secure code" — https://msrc.microsoft.com/blog/2019/07/a-proactive-approach-to-more-secure-code/
- Google Project Zero, 2019 — "Project Zero: The Rule of 2" — https://googleprojectzero.blogspot.com/2019/04/
- CISA — The Case for Memory Safe Roadmaps: https://www.cisa.gov/resources-tools/resources/case-memory-safe-roadmaps
- NSA Cybersecurity Information Sheet, 2022 — "Software Memory Safety" — disponível em https://www.nsa.gov/Press-Room/News-Highlights/Article/3215760/
- Rustup — instalação oficial — https://rustup.rs
- rust-analyzer — https://rust-analyzer.github.io