Recentemente comecei a aprender Rust: tenho apanhando bastante e está sendo um aprendizado imenso para todos nós. Neste post conto o que iniciou esta jornada, minhas impressões iniciais, oportunidades e também uma bibliografia comentada que pode ajudar quem queria começar o aprendizado.

Como tudo começou

Rust entrou em nossa vida através do estudo arquitetural de um projeto que desenvolvemos para um cliente. Tudo surgiu dos requisitos.

• A aplicação seria executada em computadores desktop.
• Estes computadores poderiam ser máquinas bem antigas, baseadas em Windows 7 com no máximo 2 Gb de RAM.
• A solução iria substituir um sistema antigo, baseado em Delphi, cujo custo de licenciamento estava se tornando um problema para o cliente.
• Deveria ser uma plataforma de desenvolvimento que fosse suficientemente popular para que pudéssemos encontrar mão de obra para o projeto no futuro.

O primeiro candidato foi o Lazarus. Caso não conheça, pense nele como um “Delphi open source”. É essencialmente uma IDE (bem “Delphi like”) que usa o Free Pascal como linguagem de desenvolvimento. Dá inclusive a possibilidade de importar projetos feitos em Delphi.

O problema é que tinha aqui a última versão do Delphi no projeto original usando uma série de componentes proprietários que não tornavam trivial a migração para o Lazarus. Além disto infelizmente Lazarus não é ainda tão popular quanto merecia, razão pela qual o descartamos no projeto. Foi uma pena, pois se tudo desse certo, teríamos aproveitamento total do código existente.

Partimos então para os próximos candidatos. O .net entrou na fila portanto. Um dos objetivos secundários do projeto era que seria interessante termos uma aplicação que pudesse ser executada no Windows também. Infelizmente no momento atual os toolkits gráficos para desktop no .net quando o assunto é multi plataforma ainda estão bem limitados. As soluções oficiais: WinForms, UWP e WPF ainda são “Windows only”. Uma solução poderia ser usar o GtkSharp, mas neste momento ainda não nos sentíamos seguros com ele. Por nossa falta de conhecimento. Além disto, lembra que mencionei Windows 7 lá no início? Pois é: poderia ser um problema.

Próximo candidato: Java. Yeap: é possível criar aplicações Java desktop que consomem muito pouca memória. Então fizemos algumas provas de conceito, mas ainda não era suficiente.

Foi quando fiz a prova de conceito com Rust e, bem: funcionou!

• Nossa POC consumia algo em torno de 300 a 400 kb de RAM (foi o que nos ganhou).
• O mesmo código era compilado pra Windows, Linux e macOS.
• Encontramos na plataforma Rust tudo o que precisávamos para prosseguir.
• Há uma comunidade crescente que nos facilita encontrar novos membros pra equipe no futuro.
• Abre possibilidades de implementação que valem à pena ser exploradas (mais sobre isto adiante).
• Desempenho INSANO para o que precisávamos fazer.

Também chegamos a olhar Go rapidamente, mas confesso que Rust nos ganhou com nossa primeira prova de conceito.

Impressões e dificuldades iniciais

Nossa prova de conceito em Rust se mostrou viável no meu primeiro contato com o “livro oficial do Rust” (The Book). Aos poucos fui fazendo pequenos progressos na linguagem. Saindo do “Hello World” clássico fui caminhando até o ponto em que conseguia executar duas ações essenciais para nosso projeto:

• Manipulação de uma pequena base relacional (Sqlite) .
• Realizar interações com dispositivos de rede (integração com hardware que fornece comunicação por TCP/IP pra ser mais exato).

Este foi o momento no qual caiu a ficha pra mim: “é isto”, pensei.

Prepare-se para alguns conceitos

Pensando em memória

Minha maior dificuldade, confesso, foi pensar “fora da JVM”: brincando, brincando, estou nela desde 1996 com Java 1.1. Minha dificuldade aqui foi enorme. Fora isto, a influência que JavaScript, Groovy, Java (é claro), C# acabou me atrapalhando um pouco. O que me ajudou, devo confessar, foi a pouquíssima experiência que tive com C/C++. Fazia tempo que não vivia em um ambiente que não tivesse um garbage collector!

No caso do Rust temos uma gestão de memória bem mais fácil que a do C/C++/Delphi, é baseada no conceito de “ownership“. Este meu “mais fácil” é mentiroso: levei um bom tempo até entender direito este conceito e outros como o de movimentação (move) em memória. E conceitos que nem pensava tanto mais, como memória heap e stack voltaram ao meu dia a dia.

Organizando o código e ferramental básico

O modo como módulos são criados em Rust também me deu vários nós na cabeça. O contato inicial foi árduo: na realidade, talvez tenha sido minha maior dificuldade até agora, pois há ali uma solução muito rica e nada intuitiva em sua riqueza. Mas não fique triste: com alguma prática a coisa se torna mais clara e tudo flui.

Como lidamos com o processo de construção e obtenção de dependências é maravilhoso pra dizer o mínimo. Quando peguei pela primeira vez lembrava dos meus traumas com o make (nunca fui bom de C/C++). No Rust há uma ferramenta maravilhosa chamada Cargo. Pense nele como o Maven/Gradle do Java, o NuGet do .net, o Composer do PHP ou o NPM/Webpack do JavaScript, mas voltado para uma linguagem de mais baixo nível. Como minha experiência com C/C++ lá atrás teria sido melhor se conhecesse algo assim!

O Cargo também padroniza como você organiza seu código fonte, e é assustadoramente simples. Em pouquíssimo tempo você já saberá tudo o que precisa pra poder trabalhar. Aliás, a própria instalação do Rust é ridiculamente simples.

E como IDE, tenho usado o VSCode mesmo, que atende 100% do que preciso. Aliás, me choca como esta criatura evoluí rápido. Em pouco tempo tá substituindo meu Eclipse e Visual Studio!

Não é a orientação a objetos que você está acostumado

Se você, como eu, vêm de um background como Java, .net ou PHP talvez sinta dificuldades aqui. Isto por que Rust pelo que pude entender não é uma linguagem orientada a objetos em si, mas sim uma linguagem que possui aspectos de orientação a objetos. (achou confuso? Dá uma lida nisto aqui.)

Em Rust a estrutura mais próxima que temos de uma classe são as structs (algo que sempre quis ver no Java, e que existe no .net). Estas contém essencialmente apenas os dados que serão trafegados, e o comportamento associado, o fazemos a partir da implementação de traits. Se você vêm do Java, faça uma analogia com o conceito de interfaces. Uma struct pode ter inclusive inúmeras traits (conjunto de métodos) implementados, o que dá até um gostinho de herança múltipla.

Também não há herança em Rust: você irá trabalhar essencialmente com composição aqui.

É uma linguagem de mais baixo nível, e você deve saber disto

Este aspecto é essencial e você deve ter isto em mente sempre: não estamos falando de uma linguagem de alto nível como Java ou C# aqui. Você está muito mais próximo do hardware, tanto que é uma linguagem que talvez substitua C++ na Microsoft como linguagem para desenvolvimento Windows.

Isto quer dizer que você precisa se preocupar com gerenciamento de memória, que muita coisa precisa ser feita “manualmente”. Por exemplo: ainda não há uma forma de se definir facilmente valores default para campos de structs (eu sei da trait Default, mas ainda não é tão simples assim). Se você já programou em C++, pense em Rust como um “C++ muito mais amigável, com ferramental de linguagens de alto nível”.

Você vê o compilador muito mais presente: há macros em Rust que lembram muito o pré-processador que temos no C/C++ e Delphi, por exemplo. O próprio processo de compilação, que é por ligação estática (padrão), facilitando a implantação, salta aos olhos nesta primeira impressão.

( E por falar em compilador… é incrível o tanto que você aprende com ele! As mensagens de erro são muito instrutivas. Ele também é minha maior reclamação: ainda o acho bem lento se comparado com o que tenho em Java )

Mas vai além disto, você pode, por exemplo, realizar o desenvolvimento de soluções embarcadas com Rust, algo que não é tão natural assim em Java ou C++, por exemplo. E isto abre uma possibilidade IMENSA para todos nós que estamos acostumados a desenvolver na maior parte das vezes aplicações web.

Bibliografia comentada

Lá atrás neste post mencionei o livro oficial do Rust, “The Book”, certo? Em teoria este seria O caminho pra se aprender Rust, seria a fonte primária do aprendizado, mas na minha experiência, não foi.

Há um problema com este livro: ele menciona conceitos que só serão descritos muitas vezes muitos capítulos a frente. E isto dificulta horrores o aprendizado de quem está começando. Sendo assim nesta seção te ajudo a aprender mais rápido Rust com minhas sugestões de leitura.

Por onde começar: o livro do Castellani!

Sem sombra de dúvidas este livro tá no top 5 dos livros técnicos que li este ano. É publicado pela editora Casa do Cóidgo e pode ser comprado neste link. Este livro tem o que o livro oficial do Rust não: os capítulos são quase todos auto contidos.

Isto quer dizer que na esmagadora maioria das vezes, quando você termina a leitura de um capítulo, viu nele tudo o que precisa. Claro, há menções a recursos que não são tratados no próprio livro do Catellani (como as diretrizes ([#algo]), mas são exceção à regra.

E a linguagem também é muito boa: fiquei um final de semana inteiro debruçado sobre este material e foi aí que comecei a ficar REALMENTE produtivo na linguagem. Entenda: este livro não é uma descrição completa da linguagem, mas um kickstart.

O livro vai até tratar de alguns conceitos mais avançados, como as macros, mas não é ali que ele brilha: é ao nos dar a base pra que aí sim, possamos entender melhor o restante do material que vou citar aqui.

Não é exagero: este foi o livro que viabilizou Rust pra mim. É muito bom ver algo tão bom escrito em língua portuguesa. Obrigado Castellani!

Após o livro do Catellani

The book

Após o livro do Catellani voltei para o “The Book”. É um material que você obrigatoriamente precisará ler de cabo a rabo, e com muita paciência. É também importantíssimo que você contenha sua ansiedade na leitura pois realmente: o tempo inteiro nos capítulos são feitas menções a conceitos que só serão descritos muito, muito, muito adiante.

Apesar destes problemas, é um excelente livro. Vai além da linguagem inclusive. E é de graça! Você pode ler aqui.

The Rustlings Course

Existe um projeto no Github chamado “rustlings” que é essencialmente um tutorial interativo de Rust. Seu funcionamento é muito simples:

• Instale o Rustlings ou clone o repositório.
• Execute o Rustlings, que irá te mostrar uma série de exercícios.

Em sua maioria os exercícios consistem em corrigir código que esteja quebrado. E isto é lindo, pois você vai estar treinando manutenção de código Rust enquanto aprende a linguagem.

Executei o The Rustlings Course junto com o “The Book”. Me ajudou horrores!

Material auxiliar

Rust by Example – disponível também no site oficial da linguagem, contém um monte de exemplos que ajudam a entender tudo sobre a linguagem. Usei muito como fonte de referência quando queria ver como era aplicada alguma feature da linguagem.

crates.io – É o “Maven Central”/”NPM”/”Nuget” do Rust aonde você encontrará todas as bibliotecas escritas pela comunidade. O bacana é que a linguagem incentiva muito a produção de documentação, e pra diversas bibliotecas a documentação é muito, muito, muito boa.

Zero to Production – é um livro maravilhoso sobre como desenvolver aplicações web com Rust usando o framework Actix Web e que cobre todo o ciclo de desenvolvimento, desde a definição dos requisitos até a configuração da integração contínua, testes, implantação, segurança, performance, etc. Muito bom.

Guia do Rocket – Rocket é um framework pra desenvolvimento web muito popular no Rust. Não o adotamos por que ainda requer o uso de versões instáveis do Rust pra ser executado, mas seguindo o seu guia foi a primeira vez que escrevi uma aplicação web com a linguagem. Por isto acredito que seja uma referência interessante.

Ajuda da comunidade no /dev/All

Criamos um grupo de estudos de Rust no Discord do /dev/All. O pessoal tem ajudado bastante ali: já realizamos alguns encontros virtuais e tenho aprendido HORRORES lá. Pothix e o Júlio Brito tem me ensinado MUITO MUITO ali. Convido todos vocês a participar clicando neste link.

Oportunidades

Rust viabiliza alguns mercados que considero muito interessantes: o primeiro deles diz respeito ao desenvolvimento de aplicações web.

Desenvolvimento web de baixíssimo custo computacional

Lembra que mencionei que nossa aplicação era pra ser executada no desktop? Então: ela é executada no desktop, mas como um servidor web. Há frameworks muito interessantes para o desenvolvimento de aplicações web com Rust. Validamos três opções:

• Rocket
• Actix Web
• Gotham

No que diz respeito à documentação, Rocket e Actix Web empatam: ambos possuem excelente documentação. O que me afasta do Rocket ainda é o fato deste precisar de versões instáveis do Rust para executar, o que não nos deixa seguros neste momento.

Já o Gotham, que também é bem interessante, perde pela documentação, que tá bem a par das demais, mas é relativamente fácil de usar, por isto o levamos em consideração.

Como mencionei, optamos pelo Actix: boa documentação, usa a versão estável do Rust e mostrou excelente desempenho. E este é o ponto: quando nossa prova de conceito estava pronta, realizando 60 consultas por segundo ao nosso equipamento, persistindo os dados em uma base Sqlite e publicando os resultados na web, sabe qual foi nosso consumo final de memória? Senta aí: 1.5 MEGABYTES.

E quando aplicamos testes de carga em nossa prova de conceito, com mil requisições por segundo aos endpoints que esta disponibilizava, o consumo de memória ficava em torno de 40 a 50 mb. INCRÍVEL.

Então abre-se aí uma possibilidade riquíssima para o desenvolvimento desktop: como podemos servir além dos endpoints também conteúdo estático, embarcamos uma interface feita em React em nossa prova de conceito e voilá! Um servidor web simples, bem funcional, consumindo o mínimo de recursos computacionais e, de quebra, ainda com uma interface moderna. O Chrome consome ordens de magnitude mais memória que nossa solução.

E quando levamos em consideração a condição atual do país, com Dólar que chega perto de seis reais, a possibilidade de usarmos servidores bem menores na cloud entra como uma oportunidade real.

Embarcados

Rust permite desenvolver aplicações embarcadas usando a mesma linguagem. Então com basicamente o mesmo conjunto de conhecimentos você pode entrar neste mercado que pode ser muito lucrativo e até mesmo mais interessante que o desenvolvimento web convencional.

Se você não tem conhecimento algum sobre desenvolvimento de software embarcado, é disponibilizado inclusive um excelente material no site oficial da linguagem que pode ser acessado neste link.

Desenvolvimento Windows nativo

O Windows tem uma API poderosíssima que é muito pouco usada pela esmagadora maioria dos desenvolvedores pois é mais amigável pra quem programa em C++ que, infelizmente, não é tão difundida entre nós (ao menos não na minha bolha). Com o investimento que a Microsoft está fazendo em Rust, hoje é possível acessar toda a API nativa do Windows com a linguagem.

Isto é possível com o projeto Rust for Windows que você pode acessar neste link. Até então estava achando a plataforma Windows irrelevante graças à web, mas há uma oportunidade aqui. A partir do momento em que estas APIs se tornam mais acessíveis, há a possibilidade de se fazer um dinheiro interessante com o desenvolvimento de aplicações nativas pra Windows. Vamos ver como será o Windows 11.

Nem tudo é lindo

Rust seria uma linguagem perfeita se tivesse a acessibilidade do Groovy. Infelizmente não é o caso: justamente por ser uma linguagem de mais baixo nível e ter um modelo de desenvolvimento mais procedural (com muita coisa funcional também), quem está acostumado com o “OO padrão Java/.net/php” vai apanhar bastante: é o meu caso.

O principal problema é a curva de aprendizado, mas acredito que a sua será melhor que a minha se seguir a bibliografia que mencionei, pois o livro do Catellani realmente ajuda muito.

Indo em frente

Estamos em nossos primeiros projetos com Rust: há a limitação da curva de aprendizado (é fácil pra quem já aprendeu), mas as oportunidades e os resultados que estamos obtendo tem justificado o esforço. Temos criado projetos absurdamente eficientes com Rust, e isto é muito animador.

Pessoalmente, fico satisfeito também em estar temporariamente (por quanto tempo?) um pouco mais distante do Java este ano: Rust, JavaScript, Python e Ruby tem sido minhas principais ferramentas neste período.

Estou pensando em escrever mais a respeito de Rust aqui no blog no futuro, vamos ver o que saí. Enquanto isto, tenho aprendido horrores no Discord da Taverna. Aparece lá depois pra gente conversar, ok? De novo o link.