Rust e dificil

Durante muitos anos trabalhei com C e outras linguagens voltadas ao desenvolvimento de sistemas. Nesse período, sempre ouvi as mesmas frases sobre Rust:

"O compilador briga com você."

"Ownership é complicado."

"O Borrow Checker é um pesadelo."

"A curva de aprendizado é enorme."

Confesso que isso fez com que eu adiasse meu primeiro projeto por bastante tempo. Até que resolvi parar de assistir vídeos e ler livros e começar a escrever código.

Mas, em vez de fazer mais um "Hello, World!", escolhi algo que realmente colocasse a linguagem à prova: desenvolver uma aplicação Web Full Stack utilizando Axum, Askama, Tokio, SQLx e PostgreSQL.

O objetivo era simples: descobrir se Rust realmente era uma boa opção para desenvolvimento web moderno. No fim do projeto, percebi que a maior dificuldade não era aprender uma nova linguagem. Era abandonar hábitos que carreguei durante anos programando em C e em outras linguagens. Foi justamente nesse momento que Rust começou a fazer sentido.

A mudança de mentalidade

Rapidamente percebi que não bastava aprender uma nova sintaxe. Era necessário mudar completamente a forma de pensar sobre memória, compartilhamento de dados e concorrência. Conceitos como Ownership, Move, Borrow e Lifetimes deixaram de ser apenas termos da documentação e passaram a fazer parte do meu dia a dia.

No início, tudo parecia burocrático. A ideia de que cada valor possui um único dono, que sua propriedade pode ser transferida (move) e que referências precisam obedecer a regras rigorosas parecia um excesso de complexidade. Mas, conforme o projeto crescia, ficou claro que essas regras existiam para proteger o código, e não para dificultar o desenvolvimento. Quando essa chave virou, muita coisa simplesmente passou a fazer sentido.

O Borrow Checker

No começo, enxergava o Borrow Checker como meu maior inimigo. Cada erro de compilação parecia uma barreira desnecessária. Com o tempo, porém, minha percepção mudou completamente. Hoje o vejo como um parceiro de programação.

É como ter um desenvolvedor experiente fazendo code review em tempo real antes mesmo da aplicação ser executada. Ele impede problemas que, em muitas outras linguagens, provavelmente só apareceriam durante os testes ou, pior ainda, em produção:

referências inválidas;

uso de memória já liberada;

múltiplas referências mutáveis;

data races;

diversos comportamentos indefinidos.

Depois que compreendi isso, passei a confiar muito mais no código que estava escrevendo.

Outro ponto que me surpreendeu foi o compilador realmente ensina. Recorrer algumas vezes a recursos como:

#[axum::debug_handler]

e

#[tracing::instrument(skip_all)]

para entender alguns erros ou melhorar a observabilidade da aplicação.

Mas logo percebi que o compilador do Rust faz muito mais do que apontar um erro. Na maioria das vezes, ele explica por que o problema aconteceu, indica exatamente onde ele começou e frequentemente sugere como resolvê-lo. Tive a sensação de que o compilador responde muito bem... desde que você saiba fazer a pergunta certa.

Outro recurso que rapidamente entrou para minha rotina foi o Clippy e Check.

Inicialmente imaginei que o "clip" fosse apenas mais um linter. Na prática, ele ensina Rust. Suas sugestões ajudam a escrever código mais idiomático, simplificam implementações e apontam melhorias de desempenho e legibilidade. Em diversos momentos tive a impressão de estar aprendendo Rust através das recomendações do próprio compilador.

Outro recurso que rapidamente entrou para minha rotina foi o "cargo check".

No início eu utilizava apenas o "cargo build".

Depois percebi que estava desperdiçando tempo.

Enquanto o "cargo build" gera o executável da aplicação, o "cargo check" executa praticamente todas as verificações do compilador sem produzir o binário.

Na prática, isso reduz significativamente o tempo de feedback durante o desenvolvimento.

Já o "cargo build" também me surpreendeu por outro motivo.

Descobri que ele não recompila todo o projeto a cada alteração.

Graças à compilação incremental e ao sistema de cache do Cargo, apenas o que realmente mudou é recompilado.

Quem vem do mundo de C sabe quanto tempo já foi gasto ajustando Makefiles, dependências entre arquivos e regras de compilação.

No Rust, boa parte dessa complexidade simplesmente desaparece.

Você consegue concentrar seus esforços na lógica da aplicação enquanto o Cargo cuida da infraestrutura de build.

Desenvolvendo aplicações Web com Rust

Antes deste projeto, eu associava Rust principalmente a sistemas operacionais, software embarcado e ferramentas de linha de comando.

Construir uma aplicação Web Full Stack mudou completamente essa percepção.

Utilizando Axum, Askama, Tokio, SQLx e PostgreSQL, encontrei um ecossistema moderno, consistente e muito agradável de trabalhar.

A integração entre as bibliotecas é excelente, o gerenciamento de dependências é simples e o compilador transmite uma sensação constante de segurança.

É claro que ainda existem desafios.

Ownership e Borrow Checker continuam exigindo atenção.

Mas hoje percebo que boa parte dessa dificuldade está concentrada no início da curva de aprendizado.

Depois que os conceitos são assimilados, eles deixam de parecer restrições e passam a funcionar como ferramentas para escrever software mais seguro, robusto e fácil de manter.

Conclusão

Hoje enxergo Rust de uma forma completamente diferente daquela que tinha quando comecei.

Ao longo da minha carreira encontrei qualidades que admirei em diferentes linguagens.

Em C, aprendi a importância de compreender como memória e hardware realmente funcionam.

Em C#, passei a valorizar produtividade, organização do ecossistema e qualidade das ferramentas.

Em Go, gostei da simplicidade, da concorrência e da facilidade para construir serviços modernos.

O que mais me chamou a atenção no Rust foi encontrar muitas dessas qualidades reunidas em uma única linguagem, sem abrir mão do desempenho.

Vejo Rust como uma evolução natural para sistemas em que performance continua sendo importante, mas segurança, concorrência e facilidade de manutenção também se tornaram prioridades.

Meu primeiro projeto Web Full Stack foi suficiente para mudar completamente minha percepção sobre a linguagem.

Ainda tenho muito a aprender.

Mas hoje entendo por que tantas empresas estão apostando em Rust para construir sistemas críticos e aplicações de alta performance.

Mais do que uma linguagem rápida, Rust incentiva você a escrever software melhor desde o primeiro "cargo build".

E talvez essa tenha sido a maior lição desse projeto:

O compilador não está brigando com você. Ele está trabalhando ao seu lado para impedir que muitos problemas cheguem à produção.

E você? Depois de aprender uma nova tecnologia, já teve alguma experiência que mudou completamente a sua forma de programar?