Recentemente eu gravei um podcast sobre Rust com alguns amigos da comunidade de Rust que conheci. Como eu tinha muito interesse na linguagem e nenhuma experiência eu fui estudar antes de gravar o podcast para poder fazer as perguntas certas e trazer um pouco das minhas experiências ao começar com a linguagem.

Fiz o curso de Rust da Pluralsight, experimentei com um monte de funcionalidades, compilei projeto com código beta, no Windows, no Linux, usei Vim, Visual Studio, várias CLIs diferentes, foi tudo muito interessante. Mas tudo isso eu poderia dizer de qualquer nova linguagem da moda, e não estaria escrevendo esse post só por causa disso, apesar de aprender uma tecnologia nova ser sempre muito interessante e bem vindo.

O motivo de eu estar escrevendo esse post é pelo que encontrei no Rust, pela sua capacidade de revolucionar a indústria. E pra isso você tem que entender a motivação por trás da criação do Rust. Rust foi criado desde o princípio para ser uma linguagem de baixo nível segura e aprazível. O argumento é que, ainda que C e C++ sejam linguagens excelentes, é praticamente impossível escrever código seguro com ela quando falamos de um grande projeto com muitas pessoas colaborando. A gestão de memória é complexa, o controle da concorrência é ainda mais complexa, e por causa destes problemas (e de outros) você acaba precisando trabalhar somente com programadores muito experientes para garantir estabilidade do software final, algo impossível em grandes projetos. E, mesmo nesse caso, a demanda de coordenação entre as pessoas é exponencial, e muito difícil de garantir que funcionará. O resultado é uma série de bugs e vulnerabilidades que normalmente vemos em softwares escritos com C e C++, que só podem ser mitigados com muitos testes.

Rust endereça esses problemas. E não só estes. Rust é uma linguagem moderna, divertida, totalmente adequada ao seu tempo. É uma linguagem de baixo nível, que permite escrever código que vai rodar nativamente no processador, assim como acontece com C e C++, mas com uma sintaxe muito mais bonita. E o mais legal é que Rust usa a ideia de abstrações de custo zero, ou seja, todo o syntax sugar que ela traz não vai custar em termos de desempenho, memória ou IO. Rust chega ao extremo de que seus binários podem ser linkados como se fossem bibliotecas C.

Rust é uma linguagem moderna porque traz construções que aprendemos a gostar, mas que são estranhas ou não existem em linguagens mais antigas. Rust tem sintaxe para tuplas, pattern matching, e é imutável por padrão, o que faz parecer que é uma linguagem funcional. Seria melhor dizer que ela tem características funcionais, porque também tem características de OO.

Hoje em dia está na moda criar novas linguagens de baixo nível, ou que falam mais perto da máquina, ou que permitem mais concorrência. Nessa esteira veio o Go por exemplo. Mas existe uma distância considerável entre as linguagens. Somente para citar um exemplo, mas não um pequeno, Go é uma linguagem com Garbage Collection, Rust não é. Isso já deixa bem claro pra mim qual está mais perto do metal. Além disso, Go não oferece as garantias de segurança que Rust oferece. Ainda preciso me aprofundar mais em Go, e farei isso, mas me parece que Rust oferece mais benefícios, olhando de 100 metros de altura. Mas o mascote de Go é mais legal. 😃 Pra endereçar problemas de concorrência surgiram linguagens como o Elixir, baseada em tecnologia pensada para décadas atrás feita para lidar com concorrência em nós de rede. Mais uma vez, Rust resolve o problema com uma estratégia muito mais simples, sem que você precise criar abstrações pouco naturais para modelar o mundo real, sem incorrer em problemas de concorrência no acesso na memória, e sem precisar fingir que tem “mini servidores” nos seus processadores, ou pagar por essas abstrações. Tudo com desempenho muito superior, afinal estamos falando de código nativo, sem GC. Disclaimer: o objetivo não é iniciar um flame war nesses pontos, apenas apontar que Rust resolve alguns problemas extremamente complexos de forma extremamente simples. No fim, use o que preferir, e se quiser reclamar sobre esses pontos mesmos depois deste disclaimer, sempre existem outras caixas de comentários que não a deste blog, divirta-se com elas.

Não bastasse tudo isso, Rust ainda tem um código de conduta, e eles são sérios a respeito das políticas de inclusão e segurança. A mensagem que os membros do core team cantam a todos os lados é clara: se você não concorda em trabalhar de forma respeitosa e atender o código de conduta vá embora, o seu lugar não é aqui. Eles são especialmente cuidadosos com pessoas que não tem um background forte de programação de baixo nível, e com grupos sub representados na tecnologia, como o de mulheres. E eles falam sobre isso. O que mais querer de uma grande linguagem senão uma comunidade preparada para o século XXI, que vive o momento do seu tempo?

Rust começa a dar resultados e a entregar suas promessas. Acabo de instalar o beta do Firefox 57 (também chamado de Quantum), que saiu nesta terça-feira. Todo o engine de CSS foi refeito do zero, em Rust. Eles estão alterando o Gecko também para começar a substituir partes dele por componentes feitos em Rust, mas essas partes ainda não entrarão no FF 57. Existe um projeto chamado Servo que é onde a inovação está sendo estudada. O resultado é que em Novembro sai o Firefox 57, que será o navegador mais rápido do mercado, como você pode ver no vídeo abaixo. E neste link você lê mais sobre o Quantum.

Aqui um vídeo mostrando o WebRender do Servo ao lado do Chrome (que ainda não sai no FF 57):

Se você quiser olhar pro Rust, o ambiente mais estável é o Linux. No Windows apanhei um pouco pra colocar tudo no ar e algumas coisas não funcionam tão bem. No Linux basta usar o VS Code, instalar as extensões e tudo funciona, inclusive o debug. No Windows, a extensão de Rust para Visual Studio chamada Visual Rust parece cumprir a mesma função, mas ela ainda não atualizou pro Visual Studio 2017, então ainda não testei. O debug com VS Code não funciona ainda no Windows.

Abaixo alguns recursos para você começar.

Abaixo um exemplo rápido da linguagem (tirado daqui). Nesse exemplo você vê os poderosos Enums de Rust, e uma função de pattern matching.

enum UsState {
    Alabama,
    Alaska
}
enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}
fn value_in_cents(coin: Coin) -> u32 {
    match coin {
        Coin::Penny => {
            println!("Lucky penny!");
            1
        },
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

O podcast que gravamos sairá dia 20 de Outubro (menos de um mês), será o número 66. Já está prontinho, editado e tudo, e ficou muito legal. Se vocês gostaram dessa rápida introdução ao Rust, não deixem de ouvi-lo. Espero que vocês curtam. Até lá, bora estudar Rust!

E se você curte Rust, comente aqui no blog como tem sido pra você trabalhar ou estudar Rust. Ou nos conte o que descobriu com Rust depois que foi atrás após conhecer a linguagem por aqui.