Será Rust um caminho desafiante ?

1. O que é o Rust?

Rust é uma linguagem de programação de sistemas criada pela Mozilla - seria mais correto dizer que começou com uma iniciativa experimental e pessoal de Graydon Hoare, um engenheiro de software em 2006 -  em 2010 (e lançada estável em 2015) que promete uma coisa que parecia impossível:

"Performance de C/C++ com segurança de memória garantida em tempo de compilação."

O que significa "linguagem de sistemas"?

É o tipo de linguagem usada para construir as fundações que outras coisas correm por cima:

• Sistemas operativos (partes do Windows, Linux kernel, Android)
• Navegadores web (Firefox, Chrome, Safari)
• Motores de jogos
• Base de dados (SurrealDB, TiDB)
• Ferramentas de linha de comandos (ripgrep, fd, bat)
• Infraestrutura (Docker, Kubernetes em partes, AWS Lambda)
• Drivers de hardware, firmware, dispositivos IoT
• E também: APIs web, apps desktop, apps mobile, IA

Analogia: Se Python/JavaScript fosse como construir casas com madeira (fácil, rápido, mas  podemos facilmente pegar fogo), Rust seria como construir com aço e cimento armado (exige planeamento, mas não cai).

2. Porque é que o Rust existe?

O problema de algumas décadas

Desde os anos 70 que existe um dilema na programação:

Linguagens como C/C++	Linguagens como Java/Python/JS
✅ Muito rápidas	✅ Fáceis de usar
✅ Controlo total da memória	✅ Sem crashes de memória
❌ Bugs de memória (70% dos CVEs da Microsoft e Google vêm daqui)	❌ Lentas (garbage collector)
❌ Crashes difíceis de debugar	❌ Mais memória consumida

Os "bugs de memória" que o Rust quer evitar

1. Use-after-free — Usar memória que já foi libertada (crash ou vulnerabilidade)
2. Double-free — Libertar a mesma memória duas vezes (corrupção)
3. Buffer overflow — Escrever além do espaço alocado (abertura para hackers)
4. Data races — Duas threads a aceder/modificar o mesmo dado ao mesmo tempo
5. Null pointer dereference — O famoso "billion dollar mistake" (Tony Hoare, 1965)

Nunca iremos conseguir descobrir o custo destes bugs: A Microsoft estimou em 2019 que 70% das vulnerabilidades de segurança que eles corrigiam vinham de problemas de memória. O Google reportou números semelhantes para o Chrome.

A solução do Rust

Em vez de um garbage collector (como Java/Go) que limpa a memória em runtime, ou um programador responsável (como C/C++) que pode errar, o Rust introduziu um sistema de ownership verificado em tempo de compilação.

Uma comparação simples:

• C/C++: Dão-te as chaves do carro e dizem "não batas". Se bateres, é tarde demais.
• Java/Python: Tens um motorista automático (GC), mas é lento e consome combustível.
• Rust: O carro não liga se não tiveres capacete, cinto e carta. Parece chato, mas chegas inteiro e rápido.

---

3. No que se diferencia das outras linguagens?

Os 4 pilares do Rust

Pilar	Significado	Analogia
Ownership	Cada pedaço de memória só pode ter um dono de cada vez	Um livro só pode estar na estante de uma pessoa
Borrowing	Podes emprestar referências, mas com regras	Podes emprestar o livro, mas regras claras sobre quem lê e quando
Lifetimes	O compilador verifica que as referências não sobrevivem aos dados	O empréstimo tem prazo de validade
Zero-cost abstractions	Funcionalidades de alto nível não custam performance em runtime	Iteradores em Rust são tão rápidos como loops manuais em C (1)

(1) Isso significa que o compilador pega o seu código elegante e cheio de funções e o transforma, por baixo dos panos, num código de máquina puramente linear, exatamente idêntico (ou às vezes até melhor) ao que um programador experiente escreveria manualmente em C.

Diferenças práticas vs linguagens que talvez conheças

Conceito	Python/JavaScript	Java/C#	C/C++	Rust
Null	None/null por todo o lado	null causa NullPointerException	Ponteiros nulos	Option — obrigatório tratar
Erros	Exceções (try/except)	Exceções	Códigos de erro ignoráveis	Result — o compilador obriga
Mutabilidade	Tudo mutável por defeito	Tudo mutável por defeito	Tudo mutável	Imutável por defeito, mutabilidade explícita
Threads	GIL (Python) limita; JS é single-thread	Threads com risco de data races	Threads com risco de data races	Compilador impede data races
Memória	Garbage collector	Garbage collector	Manual (com riscos)	Ownership system (sem GC, sem riscos)

---

4. Vantagens vs Desvantagens

Depois de alguma pesquisa, encontra-se abaixo um resumo das vantagens e desvantagens que encontrei referenciadas.

✅ Vantagens

Performance previsível 

- Sem garbage collector a pausar o programa 

- Controlo total sobre alocações de memória 

- Tão rápido quanto C/C++ na maioria dos casos 

Segurança de memória garantida 

- Classes inteiras de bugs não compilam 

- Sem segmentation faults em código safe 

- Sem data races em código multi-thread 

Compilador como professor 

- Mensagens de erro excelentes (melhores que qualquer outra linguagem) 

- Sugere correções, explica o porquê 

- Aprendes conceitos profundos só por ler os erros 

Ecossistema moderno 

- cargo é considerado o melhor gestor de pacotes da indústria 

- crates.io com milhares de bibliotecas de qualidade 

- rust-analyzer oferece IDE experience de topo 

Concorrência sem medo 

- Podes usar todas as cores do CPU sem risco de corrupção 

- Async/await é poderoso e bem suportado (Tokio) 

Adoção crescente 

- Linux kernel aceita Rust desde 2022 

- Microsoft, Google, AWS, Cloudflare, Discord, Dropbox usam em produção 

- "Linguagem mais amada" no Stack Overflow por 9 anos seguidos (2016-2024) 

Multi-plataforma 

- Corre em: servidores, browsers (WASM), desktop, mobile, IoT, embedded, consolas

❌ Desvantagens

Curva de aprendizagem íngreme ⚠️ 

- Os primeiros 2-3 meses são difíceis 

- O borrow checker vai rejeitar código que "parece correcto" 

- Conceitos como ownership, lifetimes e Send/Sync exigem mudança mental 

- Esta é a razão #1 pela qual as pessoas desistem 

Tempo de compilação 

- Projetos grandes demoram a compilar (minutos em CI) 

- cargo check é rápido, cargo build --release é lento 

Ecossistema ainda a amadurecer 

- GUIs nativas não são tão boas quanto Electron/Qt 

- Menos bibliotecas que Python para certas áreas (ex: data science pura) 

- Game dev é possível (Bevy) mas menos maduro que Unity/Unreal 

Muito verboso às vezes 

- Lidar com Result e Option explicitamente cansa no início 

- Lifetimes em assinaturas de funções podem parecer burocracia 

Debugging async pode ser complexo 

- Stack traces em código async são menos informativas 

- Exige ferramentas específicas 

Menos ofertas de emprego (por enquanto) 

- Ainda é nicho vs Java/Python/JS 

- Mas a tendência é de crescimento forte e salários altos

Vamos ver se os próximos tempos serão desafiantes e se estamos á altura do desafio ! Comecemos ?