Desbravando Rust

Cargo contra rapa

Por @zejuniortdr em Dez 03, 2025

Se você vem de linguagens como JavaScript, Python ou PHP, provavelmente já passou pela “fadiga de configuração”. Você quer começar um projeto novo e a primeira hora é gasta decidindo qual gerenciador de pacotes usar, configurando o linter, o formatador, o framework de testes e o bundler.

E se eu te dissesse que no Rust, essa decisão já foi tomada por você, e ela é incrivelmente boa?

Apresento o Cargo: o gerenciador de pacotes, sistema de build, executor de testes, gerador de documentação e melhor amigo do desenvolvedor Rust, com uma prévia do que encontrará no livro que pode ser adquirido no link no final deste post.

O Caos do Tooling Moderno

Para entender o valor do Cargo, precisamos olhar para o estado atual de outras stacks populares. Não me entenda mal, essas linguagens são fantásticas, mas o tooling… bem, é complicado.

O Ecossistema JavaScript/TypeScript

Bem-vindo ao paradoxo da escolha:

Gerenciador de Pacotes: npm? yarn? pnpm? bun?
Build/Bundle: Webpack? Rollup? Vite? Esbuild? Turbopack?
Testes: Jest? Mocha? Vitest? Ava?
Linting/Formatting: ESLint? Prettier? Biome? Standard?

Configurar um projeto TypeScript moderno do zero é quase um rito de passagem. Você precisa de um package.json, tsconfig.json, .eslintrc, .prettierrc, jest.config.js… e torcer para as versões conversarem entre si.

O Ecossistema Python

Python é famoso por ser fácil de ler, mas difícil de gerenciar:

Gerenciamento de Dependências: pip puro? poetry? pipenv? O novo e promissor uv?
Ambientes Virtuais: venv? virtualenv? conda?
Formatação/Linting: black? flake8? pylint? ruff (escrito em Rust, diga-se de passagem)?

O meme “Python environment hell” existe por um motivo.

Python Environment Hell

O Ecossistema PHP

O PHP evoluiu muito. O Composer é uma obra de arte e salvou a linguagem. Mas ele foca estritamente em dependências. Para um workflow completo, você ainda precisa costurar:

Testes: PHPUnit ou Pest?
Análise Estática: PHPStan ou Psalm?
Formatação: PHP-CS-Fixer ou Pint?

O Jeito Cargo de Ser

Rust adotou uma abordagem diferente: Baterias Inclusas. O Cargo não é apenas um instalador de bibliotecas; ele é um orquestrador de todo o ciclo de vida do desenvolvimento.

Quando você instala o Rust, o Cargo vem junto. E com ele, você tem uma ferramenta padronizada para tudo.

1. Criando Projetos (`cargo new`)

Sem perguntas complexas, sem boilerplate excessivo.

cargo new meu-projeto

Isso cria a estrutura de pastas, inicializa o git e cria o Cargo.toml (o arquivo de configuração). Pronto.

2. Gerenciando Dependências

Quer adicionar uma lib?

cargo add serde --features derive

O Cargo baixa, compila (incluindo dependências das dependências) e garante que tudo funciona. O resolver de versões do Cargo é extremamente robusto e respeita o Semantic Versioning rigorosamente.

3. Build e Execução (`cargo run`)

cargo run

Esse comando compila seu código, linka as bibliotecas e executa o binário. Se você mudar uma linha, ele recompila incrementalmente apenas o necessário.

4. Testes Integrados (`cargo test`)

Não precisa instalar nada. O Rust tem suporte a testes na própria linguagem.

#[test]
fn it_works() {
    assert_eq!(2 + 2, 4);
}

Rodou cargo test, ele encontra todos os testes (unitários, integração e até doc-tests), compila e executa em paralelo. Simples assim.

5. Formatação Padrão (`cargo fmt`)

Chega de brigas em Code Review sobre onde colocar a chave ou se usa aspas simples ou duplas. O rustfmt é o padrão oficial. Todo código Rust parece ter sido escrito pela mesma pessoa.

cargo fmt

6. O Professor Particular (`cargo clippy`)

O Clippy é mais que um linter; é um mentor. Ele não só aponta erros, mas sugere formas mais idiomáticas (“Rustacean”) de escrever seu código.

cargo clippy

Ele vai te dizer: “Ei, você está usando um loop for aqui, mas um iterator seria mais rápido e legível. Tente assim…”

7. Correções Automáticas (`cargo fix`)

Complementando o Clippy, o cargo fix pode aplicar automaticamente muitas das sugestões e correções que o Clippy (e o próprio compilador) identificam. Isso transforma warnings em ações concretas, economizando tempo e garantindo que seu código esteja sempre em conformidade com as melhores práticas da linguagem.

cargo fix --edition

8. Documentação Automática (`cargo doc`)

cargo doc --open

Esse comando gera um site estático com a documentação de todas as suas dependências e do seu próprio código, offline, navegável e padronizado. É mágico.

Por que isso importa?

A padronização do Cargo elimina a fadiga de decisão. Em vez de gastar energia configurando ferramentas, você gasta energia resolvendo o problema do seu negócio.

Se você entrar em um projeto Rust open-source hoje, seja ele pequeno ou gigante (como o kernel do Linux ou o próprio compilador do Rust), você sabe exatamente como rodar, testar e documentar: cargo run, cargo test, cargo doc.

Essa consistência cria uma comunidade mais coesa e produtiva. Enquanto outras stacks tentam reinventar a roda a cada 6 meses com uma nova ferramenta de build “revolucionária”, a comunidade Rust continua aprimorando o Cargo, que já é excelente há anos.

Conclusão

O Cargo não é perfeito, mas é o mais próximo que temos de uma “experiência de desenvolvedor ideal” em linguagens de sistema. Ele prova que uma linguagem difícil de aprender não precisa ter um tooling difícil de usar. Pelo contrário: o tooling do Rust é tão bom que muitas vezes ele te ensina a linguagem.

Se você está cansado de configurar Webpack, brigar com ambientes virtuais Python ou configurar o PHPUnit xml, dê uma chance ao Rust. O Cargo vai te mal acostumar.

Benchmarks

Recurso / Ferramenta	Cargo (Rust)	npm/Yarn/pnpm (JS)	Composer (PHP)	Pip (Python)	Pipenv (Python)	uv (Python)
Gerenciador de Pacotes	✅	✅	✅	✅	✅	✅
Sistema de Build	✅	❌²	❌	❌	❌	❌
Executor de Testes	✅	❌²	❌²	❌²	❌²	❌²
Gerador de Documentação	✅	❌²	❌	❌	❌	❌
Linter/Formatador	✅	❌²	❌²	❌²	❌²	❌²
Ambientes Virtuais	❌¹	❌¹	❌¹	❌¹	✅	✅
Resolução de Dependências	✅✅³	✅	✅	✅	✅	✅✅³
Linguagem Principal	Rust	JavaScript	PHP	Python	Python	Python

¹: Não é um conceito diretamente comparável ou necessário para a linguagem da mesma forma. No JS, node_modules local serve a um propósito similar. ²: Ferramenta externa usualmente orquestrada por scripts ou outras ferramentas. ³: Um duplo ✅ indica um sistema de resolução de dependências mais robusto e determinístico, frequentemente com um algoritmo de satisfação de booleanos (SAT solver) que garante que todas as dependências sejam resolvidas para uma única versão compatível, mesmo em grafos complexos.

Quer experimentar esse poder na prática?

No livro “Desbravando Rust”, dedicamos capítulos inteiros para explorar o ecossistema do Cargo, ensinando não só a sintaxe da linguagem, mas como usar essas ferramentas para criar software robusto, testado e documentado desde o primeiro dia.