Para entender o motivo de 86.1% dos desenvolvedores que utilizam Rust amar a linguagem, primeiro precisamos entender a sua origem:

Rust começou como um projeto pessoal de um funcionário da Mozilla, Graydon Hoare em 2006, o projeto passou a ser patrocinado pela empresa em 2009 e teve sua primeira versão (1.0) em 2010.

“A linguagem foi projetada para ajudar desenvolvedores a criarem aplicações rápidas e seguras, que queiram aproveitar ao máximo as poderosas funcionalidades dos processadores modernos multi-cores. Ela previne falhas de segmentação e garante a segurança nas Threads, tudo através de uma sintaxe fácil de aprender.

Além disso, Rust oferece custo zero nas suas abstrações, mudanças de semânticas, garantia de segurança de memória, threads sem condições de corrida, generics baseados em traits, pattern matching (casamento de padrões), inferência de tipos e binding eficiente para C, com o menor tamanho em tempo de execução.”

https://developer.mozilla.org/pt-BR/docs/Mozilla/Rust

Assim como muitas empresas de tecnologia dizem, é muito difícil escrever código seguro para coisas críticas como engines e kernels, que usualmente são escritas em C/C++ pelo controle das preocupações de baixo nível e pela performance. Ocorrem frequentemente problemas como vazamento de memória e exceções por conta de problemas com ponteiros ou até mesmo como problemas de segurança como acesso indevido a endereços de memória.

Rust preenche essas lacunas, oferecendo controle e segurança para a aplicação sem abrir mão da performance, e foi exatamente por esse motivo que a Microsoft resolveu adotar a linguagem para utilizar nos seus produtos e serviços. (Veja o artigo).

Não só a Microsoft percebeu que investir nessa nova tecnologia seria uma boa idéia, como também Linus Torvalds discute sobre a inclusão do Rust em alguns módulos do Linux (Veja o artigo).

A própria Discord usa Rust em produção para resolver problemas de picos de uso de CPU frequentes no acionamento do Garbage Collector (Veja o artigo).

Recentemente também várias big techs como Google, Microsoft, Mozilla e Amazon em conjunto lançaram uma organização sem fins lucrativos para ajudar a linguagem a se manter dando total suporte para os mantenedores que lideram e desenvolvem o projeto.

Aqui na TerraMagna utilizamos Rust na maioria dos nossos serviços, pois precisamos entregar dados com confiabilidade e agilidade para nossos clientes, por estarmos em um ramo de negócio em que qualquer erro ou imprecisão pode custar caro, a adoção do Rust caiu como uma luva para nós.

PS: Temos vagas :D

A linguagem é muito parecida com OCaml, foca muito na imutabilidade e com tipagem inferida, como no Typescript:

Esse é um exemplo bastante prático de como funciona a imutabilidade na linguagem, também um pouco de definição de variáveis e constantes e alguns tipos primitivos.

Perceba que a definição de números inteiros no rust é um pouco diferente, onde primeiro se especifica se o número vai ter sinal ou não, ou seja, se ele vai ser negativo ou não, e depois se especifica o tamanho em bits:

• u: sem sinal, ou seja, somente números positivos;
• i: com sinal, ou seja, suporta números positivos e negativos;

Options

Option é um enum da biblioteca padrão do Rust que, ou carrega um valor, ou não carrega nada, é ideal para casos onde você pode ter ou não ter um certo valor.

Nesse caso, o método find retorna um número inteiro positivo, que é o índice daquilo que você quer encontrar, mas pode ser que esse método encontre ou não encontre isso, então este retorno passa a ser uma Option<usize>, isso significa que ele pode ser Some(indice) se ele conseguir encontrar, e None se não conseguir encontrar nada, e podemos tratar dessa forma:

Também podemos fazer assim, caso quiséssemos simplesmente descartar o caso do None:

Results

Uma operação também pode retornar um valor ou um erro, ou seja, pode dar certo e pode não dar certo, e para isso temos o tipo Result que é como o Option só que ele carrega um erro:

Nesse caso, se a operação de abertura de arquivo não deu certo porque o arquivo não existe, então ele retorna um Err(err) e apresenta esse erro, e se der certo, ele retorna um Ok(file) sendo file um objeto de arquivo, e se a leitura for feita com sucesso, apresenta o conteúdo deste arquivo.

Também podemos simplificar a resolução de Results caso a função pai também retornar um Result com o mesmo tipo de erro da função filho.

Nesse exemplo, antes de fazer uma operação de divisão, avaliamos se o denominador é zero, e se for zero, retornamos um erro, caso não for, retornamos o denominador recebido.

O operador ? permite com que o erro da função filha simplesmente suba para a função pai.

Note também que para retornar um valor de uma função basta omitir o ponto e vírgula da última instrução, e se precisar retornar antes da última instrução, então usamos o return, como em outras linguagens.

Perceba que com a existência dos tipos Option e Result, a linguagem reforça a não-existência de uma declaração para valores nulos, também há outros conceitos na linguagem que dispensam completamente a existência de valores nulos como lifetimes, iremos falar um pouco mais disso agora.

Ownership

Uma das principais features do Rust é o conceito de ownership, que garante boa parte da confiabilidade em suas aplicações, é um conceito que aparenta ser simples no começo, mas que implica em algumas mudanças na forma em que você provavelmente está acostumado a escrever código.

Ownership é um conjunto de regras que são checadas em tempo de compilação com a finalidade de um gerenciamento de memória mais eficiente, e aqui estão algumas regras:

• Todos os elementos da aplicação podem ter somente um dono por vez;
• Se algum dono sair do escopo, o valor que ele possui será dropado;

Fazendo um paralelo com o mundo real, imagine que você passe a chave da sua casa para outra pessoa, você não poderia usar a sua chave mesmo que ela ainda seja sua:

O mesmo acontece nesse exemplo aqui:

Quando esse código é executado, o compilador do Rust (rustc) te retorna um erro:

Isso acontece porque a função fulano consome a chave, ou seja, agora fulano detém a posse da chave.

Para que isso não aconteça, precisamos passar uma referência de chave visto que fulano não faz nada com a chave depois que ele recebe ela:

Quando executamos esse código, o conteúdo de chave é printado na tela como era esperado desde o começo.

Isso funciona porque fulano não detém mais a chave, e sim uma referência de chave então podemos printá-lo no fim da execução do código sem nenhum problema.

Lembrando que o consumo desse valor no primeiro exemplo é dado pelo motivo de que quando ele acaba de executar a função fulano, a chave sai do escopo, exatamente como diz a segunda regra de ownership, fazendo com que seja dropado da memória e impossibilitando o seu uso posteriormente.

Agora imagine um cenário onde o fulano em questão é um chaveiro e você precisa alterar sua chave, e ainda assim precisa printá-la no final, para isso basta passar uma referência mutável para fulano e fazer as alterações necessárias:

Nesse caso, a função principal printaria outrachave.png, visto que o método insert_str insere algum &str em qualquer índice da String, e como o índice nesse caso é 0 ele colocará o valor no começo da String.

Lembrando que para conseguir passar uma referência mutável, é necessário que a definição do valor passado seja mut também, visto que não seria muito seguro se a linguagem deixasse mudar algo que não é mutável.

Você agora deve estar se perguntando no motivo de ora eu usar String ora eu usar str, qual é a diferença?

• String sempre será usado quando precisamos ter a posse desse valor, ou modificar esse valor.
• str é uma sequência imutável de bytes codificados em UTF-8 localizados em algum lugar na memória, basicamente o tipo String serve para lidar com esse tipo primitivo de forma segura, mas quando estamos lidando somente com uma referência, podemos usar &str sem nenhum problema pois nesse caso você estará apontando pra essa sequência de bytes em algum lugar da memória.

Lifetimes

Ainda no contexto de String e str considere o seguinte pedaço de código:

Nesse caso, QUX e BAZ são bastante semelhantes pois ambos definem valores &str que viverão enquanto a execução desse código viver. A diferença deles é que quando usamos static já é subentendido que o lifetime do valor será 'static que diz que o valor estará válido enquanto a execução do código viver.

Tudo que é definido possui um lifetime, mas se ele for omitido entende-se que o tempo de vida dele vai ser o mesmo do escopo, ele também pode ser explicito e como você pode ver, um lifetime pode ser anotado a partir de um ' e ele pode se referir à qualquer escopo inclusive o escopo de execução do programa ('static).

Ele serve para definir regras que ligam referências à valores, pois ainda podemos ter uma estrutura de dados que dependa de uma referência vinda de outro lugar, o que é bastante comum:

Aqui podemos dizer que enquanto name e surname viverem, person vai viver também, ou seja person não sai do escopo enquanto surname e name não sair do escopo também.

Essa é uma feature muito importante da linguagem, porque previne problemas muito comuns em outras linguagens de ter alguma estrutura ou função que aponte pra algo que não existe mais, ocasionando em erros graves em produção.

Esse conceito também previne de que aconteça o inverso: algo que foi dropado e era dependente de outra coisa, mas essa outra coisa não foi dropada e fica na memória ocupando espaço, isso é um fenômeno conhecido como memory leak.

Comunidades

Se interessou pela linguagem? Existem várias comunidades brasileiras onde tem bastante discussão e conteúdo, para poder tirar dúvidas e aprender junto!

O pessoal da @rustlangbr também preparou uma lista bem legal com vários materiais pra você deslanchar no Rust:

Temos vagas

Gostou da linguagem e quer trabalhar construindo serviços confiáveis feitos em Rust? Acesse o link e #VemSerTerraMagna