Bem-vindo ao Rust: segurança de memória sem coletor de lixo

ENTENDA A IDEIA

A ideia central

Existem duas formas tradicionais de evitar que um prédio desabe. A primeira é contratar uma equipe de plantão que percorre os andares dia e noite procurando rachaduras — funciona, mas a patrulha custa caro e nunca dorme. A segunda é não fiscalizar nada e confiar que cada morador reforça a própria parede — mais barato, até o dia em que alguém derruba uma coluna estrutural. Linguagens com coletor de lixo (Java, Go, Python, JavaScript) escolhem a patrulha: um processo em tempo de execução vigia a memória e recolhe o que ninguém mais usa. C e C++ escolhem a confiança: você aloca, você libera, e qualquer descuido vira um bug que só aparece em produção.

Exemplo Rust

let report = String::from("relatório");
let backup = report;   // a posse do texto muda de mãos
println!("{report}");  // ERRO E0382: capturado antes de o programa existir

ENTENDA A IDEIA

A ideia central

Rust propõe uma terceira via: revisar a planta do prédio antes da construção. O compilador analisa quem é o dono de cada valor, quem pode ler e quem pode escrever — e se o programa violar essas regras, ele não compila. O trecho acima é o exemplo clássico: depois que backup assume a posse do texto, usar report é rejeitado com o erro E0382. Em C++, o equivalente compila e explode em produção; em Go, o coletor mantém tudo vivo e cobra o custo em pausas e memória. Em Rust, o erro morre na compilação — você vai dominar esse mecanismo no módulo de ownership, e ele é menos assustador do que a fama sugere.

ENTENDA A IDEIA

A ideia central

Por que isso importa? Porque bugs de memória não são raros nem inofensivos: use-after-free, double free e data races respondem por cerca de 70% das vulnerabilidades graves reportadas em grandes bases de código C/C++ — número divulgado tanto pela Microsoft quanto pelo projeto Chromium. É essa classe inteira de defeitos que o Rust elimina por construção, sem pagar o preço da patrulha: não existe coletor rodando, não existem pausas imprevisíveis, e o binário final tem desempenho na mesma faixa de C. É por isso que Rust está no kernel do Linux, no Firefox, no Cloudflare Workers e em serviços de infraestrutura da AWS, do Google e da Microsoft.

ENTENDA A IDEIA

A ideia central

A mesma análise que impede o use-after-free impede outra praga no Rust seguro: o data race. Se duas threads em código seguro tentam escrever no mesmo valor sem coordenação, o programa não compila — a comunidade chama isso de fearless concurrency, e você vai ver o mecanismo em detalhe no módulo de concorrência. E tudo isso vem embalado no princípio que guia o design da linguagem: abstrações de custo zero. Iterators, generics e pattern matching compilam para o mesmo código de máquina que você escreveria à mão; a expressividade não cobra pedágio em tempo de execução.

ENTENDA A IDEIA

A ideia central

Agora, os tradeoffs honestos — porque eles existem. Primeiro: o compilador que verifica tudo isso trabalha muito, e projetos grandes têm tempos de compilação sensivelmente maiores que os de Go. Segundo: a curva de aprendizado é real. Nas primeiras semanas, o borrow checker vai rejeitar programas que você jura que estão certos — e na maioria das vezes ele terá razão, apontando um bug que em outra linguagem passaria despercebido. O contrato deste curso é atravessar essa curva do jeito certo: em vez de esconder os erros do compilador, cada aula mostra a mensagem real do rustc e decodifica o que ela está protegendo. O erro deixa de ser obstáculo e vira o professor.

ENTENDA A IDEIA

A ideia central

O formato de trabalho é o mesmo em todas as aulas: você lê um programa completo e anotado bloco a bloco, confere o painel de saída esperada, roda tudo na sua máquina com cargo run e depois resolve exercícios com casos de teste verificáveis — a solução comentada fica disponível depois que você tentar. Na próxima aula você instala a toolchain; nesta, o objetivo é ler seu primeiro programa Rust de verdade e entender cada linha.

Em Python, todo valor vive no heap e o interpretador gerencia a memória com contagem de referências mais um coletor de ciclos — você nunca pensa em quem libera o quê, e paga por isso em tempo de execução e em consumo de memória. Rust move essa contabilidade para a compilação: o custo existe, mas é pago uma vez, na sua máquina, e não a cada execução no servidor. A segunda diferença aparece já na primeira função: em Python os tipos são verificados quando a linha executa; em Rust, fn birth_year(current_year: i32, age: i32) -> i32 é um contrato que o compilador confere em cada chamada — passar um float ali nem chega a virar programa.

CÓDIGO ANOTADO

Código anotado

Este é o programa da aula: completo, executável e sem nenhuma mágica escondida. Ele define duas funções e as usa em main. Nas próximas aulas você vai criar projetos e rodar programas como este localmente; por enquanto, o exercício é de leitura — cada bloco abaixo é explicado na sequência.

src/main.rs

// birth_year estima o ano de nascimento a partir do ano atual e da idade.
fn birth_year(current_year: i32, age: i32) -> i32 {
    current_year - age
}

CÓDIGO ANOTADO

Código anotado

Quatro detalhes definem o sabor de Rust já nesta função. Funções são declaradas com fn e nomeadas em snake_case. Cada parâmetro declara seu tipo — i32 é o inteiro de 32 bits com sinal, o padrão da linguagem para números inteiros. A seta -> declara o tipo de retorno. E a última linha não tem return nem ponto e vírgula: em Rust, a última expressão do corpo é o valor devolvido. Essa distinção entre expressão e instrução volta com força na aula de funções e fluxo; por ora, registre o padrão visual.

src/main.rs

// greeting monta a mensagem de boas-vindas; format! devolve uma String nova.
fn greeting(name: &str) -> String {
    format!("Olá, {name}! Bem-vindo ao Rust.")
}

CÓDIGO ANOTADO

Código anotado

Aqui aparecem dois tipos de texto — e essa dupla vai reaparecer até você fazer as pazes com ela. &str é uma fatia de texto emprestada: a função pode ler o nome, mas o texto continua pertencendo a quem chamou. String é um texto que vive no heap e pertence a quem o criou — format! aloca essa String nova interpolando {name} no molde. O ! no final de format! e de println! indica que são macros, não funções comuns: elas verificam o molde de formatação em tempo de compilação, então um {} sem argumento correspondente é erro de compilação, não surpresa em produção.

Todo executável Rust começa em fn main. As variáveis são declaradas com let e o compilador infere os tipos: name é &str, current_year e age são i32 — anotação explícita só é necessária quando há ambiguidade. Repare no que não está escrito: nenhum tipo redundante, nenhuma liberação de memória, nenhum tratamento de nulo. E repare no que está garantido: se você trocar age por um texto, o programa não compila; se esquecer um argumento do println!, o programa não compila. A saída esperada, byte a byte:

Olá, dev! Bem-vindo ao Rust.
Você nasceu por volta de 1996

Uma última observação sobre let: essas três variáveis são imutáveis. Sem a palavra-chave mut, reatribuir um valor é erro de compilação — imutabilidade é o padrão em Rust, e mutabilidade é uma escolha declarada. A aula de variáveis e tipos explora essa decisão de design em profundidade, incluindo a mensagem de erro que ela produz.

src/main.rs

fn main() {
    let name = "dev";
    let current_year = 2026;
    let age = 30;
    println!("{}", greeting(name));
    println!("Você nasceu por volta de {}", birth_year(current_year, age));
}

PRÁTICA LOCAL

Pratique no seu computador

Copie o programa abaixo — é o mesmo da aula, inteiro — e rode com cargo run quando tiver a toolchain instalada (a próxima aula cobre a instalação passo a passo; se preferir, volte aqui depois dela).

Depois faça três alterações — e preveja o resultado de cada uma antes de compilar:

Adicione age = age + 1; logo depois de let age = 30;. O programa não compila. Antes de rodar, escreva qual das duas linhas o compilador vai apontar. A mensagem real é esta — leia o código do erro e a sugestão:

error[E0384]: cannot assign twice to immutable variable `age`
  --> src/main.rs:13:5
   |
12 |     let age = 30;
   |         --- first assignment to `age`
13 |     age = age + 1;
   |     ^^^^^^^^^^^^^ cannot assign twice to immutable variable
   |
help: consider making this binding mutable
   |
12 |     let mut age = 30;
   |         +++

O rustc mostra onde a variável nasceu, onde a reatribuição falhou e como consertar. Essa qualidade de diagnóstico não é acaso: é uma das razões de Rust liderar pesquisas de satisfação entre devs há quase uma década.

Troque let age = 30; por let age = 30.5;. Agora o erro é outro (E0308, mismatched types): birth_year exige i32 e recebeu um float. Qual linha o compilador aponta — a declaração ou a chamada? Rode e confira sua previsão.
Troque "dev" pelo seu nome e adicione uma terceira linha de saída usando println! com duas variáveis no mesmo molde. Preveja a saída exata antes de rodar.

A pergunta central do experimento: em cada erro, o que exatamente o compilador impediu de chegar em produção?

Adapte o trecho no projeto local da aula. Confira a saída esperada no enunciado.

O navegador não executa Rust. O registro abaixo confirma seu estudo, não um resultado de teste.

Pratique no seu computador

fn birth_year(current_year: i32, age: i32) -> i32 {
    current_year - age
}

fn greeting(name: &str) -> String {
    format!("Olá, {name}! Bem-vindo ao Rust.")
}

fn main() {
    let name = "dev";
    let current_year = 2026;
    let age = 30;
    println!("{}", greeting(name));
    println!("Você nasceu por volta de {}", birth_year(current_year, age));
}

Comandos locais

cargo new --bin --edition 2024 exemplo-rust
cd exemplo-rust
# Use o código no projeto da aula.
cargo run
cargo clippy -- -D warnings

Rust Playground (opcional)

DESAFIO LOCAL

Monte a saudação com format!

Escreva a função greeting, que recebe um nome e devolve a mensagem de boas-vindas completa:

pub fn greeting(name: &str) -> String

Entrada: qualquer &str, inclusive vazio.
Saída: a String "Olá, {name}! Bem-vindo ao Rust." com o nome interpolado.
Exemplo: greeting("Ana") devolve "Olá, Ana! Bem-vindo ao Rust."; greeting("") devolve "Olá, ! Bem-vindo ao Rust." — o molde não muda, mesmo com nome vazio.
Restrições: a pontuação e os espaços precisam bater byte a byte com o exemplo; os casos comparam a String inteira.

Este é o padrão que você acabou de ler no programa da aula: um molde fixo, uma interpolação, uma String nova como resultado. Rode localmente com os arquivos do exercício e confira as linhas RESULT — cada caso imprime o que era esperado e o que sua função devolveu.

O navegador não executa Rust. O registro abaixo confirma seu estudo, não um resultado de teste.

Exercício 1

Monte a saudação com format!

stub.rs

// greeting devolve a mensagem "Olá, {name}! Bem-vindo ao Rust." com o nome
// interpolado — pontuação e espaços exatamente como no molde.
pub fn greeting(name: &str) -> String {
    // implemente:
    String::from(name)
}

harness.rs

fn json_escape(value: &str) -> String {
    value
        .replace('\\', "\\\\")
        .replace('"', "\\\"")
        .replace('\n', "\\n")
}

fn print_result(case: usize, pass: bool, input: &str, want: &str, got: &str) {
    println!(
        "RESULT {{\"case\":{case},\"pass\":{pass},\"input\":\"{}\",\"want\":\"{}\",\"got\":\"{}\"}}",
        json_escape(input),
        json_escape(want),
        json_escape(got)
    );
}

fn main() {
    let cases = [
        ("Ana", "Olá, Ana! Bem-vindo ao Rust."),
        ("dev", "Olá, dev! Bem-vindo ao Rust."),
        ("", "Olá, ! Bem-vindo ao Rust."),
        ("João da Silva", "Olá, João da Silva! Bem-vindo ao Rust."),
    ];
    for (index, (name, want)) in cases.iter().enumerate() {
        let got = greeting(name);
        let pass = got == *want;
        print_result(index + 1, pass, &format!("{name:?}"), want, &got);
    }
}

cases.json

[
  {
    "case": 1,
    "input": "\"Ana\"",
    "want": "Olá, Ana! Bem-vindo ao Rust."
  },
  {
    "case": 2,
    "input": "\"dev\"",
    "want": "Olá, dev! Bem-vindo ao Rust."
  },
  {
    "case": 3,
    "input": "\"\"",
    "want": "Olá, ! Bem-vindo ao Rust."
  },
  {
    "case": 4,
    "input": "\"João da Silva\"",
    "want": "Olá, João da Silva! Bem-vindo ao Rust."
  }
]

Casos e valores esperados

Caso	Entrada	Valor esperado
1	`"Ana"`	`Olá, Ana! Bem-vindo ao Rust.`
2	`"dev"`	`Olá, dev! Bem-vindo ao Rust.`
3	`""`	`Olá, ! Bem-vindo ao Rust.`
4	`"João da Silva"`	`Olá, João da Silva! Bem-vindo ao Rust.`

Execute com o Cargo local

Execute os comandos de preparação.
Copie os arquivos acima para os arquivos vazios com os mesmos nomes.
Execute a verificação de base. O stub deve mostrar o comportamento atual.

Comandos de preparação

cargo new --bin --edition 2024 imersao-01-bem-vindo-ao-rust-exercicio-1
cd imersao-01-bem-vindo-ao-rust-exercicio-1
touch stub.rs harness.rs cases.json
printf 'include!("../stub.rs");\ninclude!("../harness.rs");\n' > src/main.rs

Verificação de base — confirme o comportamento atual antes da mudança

cargo fmt --check
cargo run --bin imersao-01-bem-vindo-ao-rust-exercicio-1
cargo clippy -- -D warnings

Abrir o Rust Playground (opcional)

Mostrar dicas

A mensagem é sempre a mesma frase com o nome no meio; a macro format! monta uma String nova a partir de um molde com chaves.
format!("Olá, {name}! Bem-vindo ao Rust.") interpola a variável direto no molde — confira a pontuação exata, os casos comparam byte a byte.

Revelar solução

solution.rs

// greeting devolve a mensagem "Olá, {name}! Bem-vindo ao Rust." com o nome
// interpolado — pontuação e espaços exatamente como no molde.
pub fn greeting(name: &str) -> String {
    format!("Olá, {name}! Bem-vindo ao Rust.")
}

format! devolve uma String alocada com o texto interpolado; a armadilha é errar a pontuação exata ou tentar concatenar &str com +, que exige uma String à esquerda e confunde quem está começando.

Uma linha resolve, e é a linha idiomática:

pub fn greeting(name: &str) -> String {
    format!("Olá, {name}! Bem-vindo ao Rust.")
}

format! compila o molde em tempo de compilação: se você escrever {nome} com uma variável que não existe, o erro aparece antes de o programa rodar — em linguagens com formatação por string em tempo de execução, esse mesmo deslize vira exceção em produção. O custo é uma única alocação no heap para a String resultante, proporcional ao tamanho do texto final: O(n) no comprimento da mensagem.

A alternativa que costuma tentar quem vem de outras linguagens é concatenar: "Olá, ".to_string() + name + "! Bem-vindo ao Rust.". Funciona, mas exige converter o primeiro pedaço para String (o operador + precisa de uma String à esquerda e consome ela), e cada + pode realocar o buffer. Para montar texto a partir de partes, format! é mais legível, faz o dimensionamento de uma vez e é o que o ecossistema espera encontrar. O caso de borda que o harness cobra é o nome vazio: o molde continua válido e a saída é "Olá, ! Bem-vindo ao Rust." — nenhum tratamento especial é necessário, e adicionar um if para esse caso seria inventar requisito.

DESAFIO LOCAL

Calcule e formate a linha de estoque

Escreva a função inventory_line, que monta a linha de um relatório de estoque calculando o total em centavos:

pub fn inventory_line(item: &str, quantity: u32, unit_cents: u32) -> String

Entrada: o nome do item, a quantidade e o preço unitário em centavos.
Saída: a String "{quantity}x {item} = {total} centavos", onde total é quantity * unit_cents.
Exemplo: inventory_line("parafuso", 3, 150) devolve "3x parafuso = 450 centavos"; inventory_line("rebite", 0, 99) devolve "0x rebite = 0 centavos".
Restrições: o total é calculado dentro da função — o chamador só fornece quantidade e preço unitário. Os valores de teste cabem em u32 sem estouro.

Aqui você combina as duas coisas da aula: um cálculo com inteiros e uma formatação com molde. u32 é o inteiro de 32 bits sem sinal — quantidades e preços não podem ser negativos, e escolher o tipo que proíbe valores inválidos é um hábito que Rust recompensa.

O navegador não executa Rust. O registro abaixo confirma seu estudo, não um resultado de teste.

Exercício 2

Calcule e formate a linha de estoque

stub.rs

// inventory_line monta "{quantity}x {item} = {total} centavos", onde total
// é quantity * unit_cents, calculado dentro da função.
pub fn inventory_line(item: &str, quantity: u32, unit_cents: u32) -> String {
    // implemente:
    let _ = unit_cents;
    format!("{quantity}x {item}")
}

harness.rs

fn json_escape(value: &str) -> String {
    value
        .replace('\\', "\\\\")
        .replace('"', "\\\"")
        .replace('\n', "\\n")
}

fn print_result(case: usize, pass: bool, input: &str, want: &str, got: &str) {
    println!(
        "RESULT {{\"case\":{case},\"pass\":{pass},\"input\":\"{}\",\"want\":\"{}\",\"got\":\"{}\"}}",
        json_escape(input),
        json_escape(want),
        json_escape(got)
    );
}

fn main() {
    let cases: [(&str, u32, u32, &str); 4] = [
        ("parafuso", 3, 150, "3x parafuso = 450 centavos"),
        ("rebite", 0, 99, "0x rebite = 0 centavos"),
        ("porca", 1, 75, "1x porca = 75 centavos"),
        ("arruela", 12, 40, "12x arruela = 480 centavos"),
    ];
    for (index, (item, quantity, unit_cents, want)) in cases.iter().enumerate() {
        let got = inventory_line(item, *quantity, *unit_cents);
        let pass = got == *want;
        print_result(
            index + 1,
            pass,
            &format!("({item:?}, {quantity}, {unit_cents})"),
            want,
            &got,
        );
    }
}

cases.json

[
  {
    "case": 1,
    "input": "(\"parafuso\", 3, 150)",
    "want": "3x parafuso = 450 centavos"
  },
  {
    "case": 2,
    "input": "(\"rebite\", 0, 99)",
    "want": "0x rebite = 0 centavos"
  },
  {
    "case": 3,
    "input": "(\"porca\", 1, 75)",
    "want": "1x porca = 75 centavos"
  },
  {
    "case": 4,
    "input": "(\"arruela\", 12, 40)",
    "want": "12x arruela = 480 centavos"
  }
]

Casos e valores esperados

Caso	Entrada	Valor esperado
1	`("parafuso", 3, 150)`	`3x parafuso = 450 centavos`
2	`("rebite", 0, 99)`	`0x rebite = 0 centavos`
3	`("porca", 1, 75)`	`1x porca = 75 centavos`
4	`("arruela", 12, 40)`	`12x arruela = 480 centavos`

Execute com o Cargo local

Execute os comandos de preparação.
Copie os arquivos acima para os arquivos vazios com os mesmos nomes.
Execute a verificação de base. O stub deve mostrar o comportamento atual.

Comandos de preparação

cargo new --bin --edition 2024 imersao-01-bem-vindo-ao-rust-exercicio-2
cd imersao-01-bem-vindo-ao-rust-exercicio-2
touch stub.rs harness.rs cases.json
printf 'include!("../stub.rs");\ninclude!("../harness.rs");\n' > src/main.rs

Verificação de base — confirme o comportamento atual antes da mudança

cargo fmt --check
cargo run --bin imersao-01-bem-vindo-ao-rust-exercicio-2
cargo clippy -- -D warnings

Abrir o Rust Playground (opcional)

Mostrar dicas

Primeiro calcule o total em uma variável (quantity * unit_cents); depois monte a frase com format! usando as três partes.
O molde é "{quantity}x {item} = {total} centavos" — repare que o total é o produto, não o preço unitário, e que zero unidades resulta em total zero.

Revelar solução

solution.rs

// inventory_line monta "{quantity}x {item} = {total} centavos", onde total
// é quantity * unit_cents, calculado dentro da função.
pub fn inventory_line(item: &str, quantity: u32, unit_cents: u32) -> String {
    let total = quantity * unit_cents;
    format!("{quantity}x {item} = {total} centavos")
}

Separar o cálculo da formatação deixa cada linha com uma responsabilidade; a armadilha é interpolar a expressão errada (unit_cents em vez do produto) ou esquecer que 0 * qualquer coisa precisa continuar produzindo uma linha válida.

Calcule primeiro, formate depois:

pub fn inventory_line(item: &str, quantity: u32, unit_cents: u32) -> String {
    let total = quantity * unit_cents;
    format!("{quantity}x {item} = {total} centavos")
}

Separar o cálculo da formatação não é frescura de estilo: a linha do format! fica declarativa (só descreve a forma da saída) e a linha do total fica auditável. O custo é O(n) no tamanho do texto final, com uma única alocação — a multiplicação de inteiros é uma instrução de máquina.

Duas armadilhas aparecem em soluções reais. A primeira é interpolar unit_cents em vez do produto — o caso ("parafuso", 3, 150) pega esse erro na hora, porque 450 ≠ 150. A segunda é o caso da quantidade zero: quem adiciona um caminho especial (“se zero, devolver outra frase”) quebra o contrato, porque o molde é fixo e 0 * 99 = 0 já produz a linha correta sem código extra. Vale registrar o que acontece se o produto estourar u32: em builds de desenvolvimento o programa encerra com panic no overflow, em vez de silenciosamente dar a volta como em C — mais um defeito que Rust prefere ruidoso a invisível. Os casos deste exercício ficam longe do limite; overflow e os tipos de inteiro maiores são assunto da aula de variáveis e tipos.

ENTENDA A IDEIA

A ideia central

Declare toda variável sem mut e só adicione a palavra-chave quando o compilador — ou o design — exigir mutação. A imutabilidade padrão transforma cada let em documentação: quem lê let total = ... sabe que aquele valor não muda até o fim do escopo, sem precisar rastrear o resto da função. O capítulo 3.1 do The Rust Book formaliza a regra e o erro E0384 que a protege. O mesmo princípio orienta a leitura de qualquer código Rust idiomático que você encontrar daqui em diante: mut é raro, visível e intencional.

RESUMO DA AULA

O que você leva desta aula

O Rust seguro garante segurança de memória em compilação: use-after-free, double free e data races são recusados. Código unsafe exige que o programador preserve essas garantias.
Os tradeoffs são reais e conhecidos: compilação mais lenta que Go e uma curva de aprendizado dominada pelo borrow checker — que este curso ataca decodificando cada erro real do rustc.
Funções declaram tipos de parâmetros e retorno; a última expressão sem ponto e vírgula é o valor devolvido, sem return.
format! e println! são macros: o molde de formatação é verificado em compilação, e format! devolve uma String nova.
Variáveis let são imutáveis por padrão (E0384 protege a regra); mut é uma escolha declarada e visível.
Na próxima aula — rustup, cargo e o primeiro projeto — você instala a toolchain e cria, compila e roda um projeto Rust de verdade na sua máquina.

+160 XPpossíveis nesta aula

A ideia central

A ideia central

A ideia central

A ideia central

A ideia central

A ideia central

Código anotado

Código anotado

Código anotado

Pratique no seu computador

Monte a saudação com format!

Casos e valores esperados

Execute com o Cargo local

Calcule e formate a linha de estoque

Casos e valores esperados

Execute com o Cargo local

A ideia central

O que você leva desta aula

Você transformou esta ideia em prática.