Você é um desenvolvedor querendo aprender Rust? Para ajudá-lo a decidir, este artigo apresenta alguns dos recursos do Rust, uma das linguagens de programação de sistemas mais populares.
Neste artigo, exploraremos a linguagem de programação Rust e seus recursos, como sistema de tipos, segurança de memória e propriedade. Também veremos uma lista de recursos que podem ajudá-lo a aprender Rust.
Vamos começar!
O que é ferrugem?
Rust é uma linguagem de programação de sistemas. Começou como um projeto pessoal de Graydon Hoare, um desenvolvedor, em 2006. Em menos de uma década, tornou-se a escolha preferida para programação de sistemas e aplicativos relacionados. O salário médio de um programador Rust é de cerca de US$ 120 mil.
Portanto, se você deseja mudar de C++ para Rust ou está procurando uma nova linguagem, aprender Rust pode ser uma ótima escolha! De acordo com a pesquisa StackOverflow Developer, Rust foi eleita a linguagem de programação mais amada – por sete anos consecutivos.
Fonte da imagem: StackOverflow
Rust oferece a velocidade de linguagens de programação de sistemas de baixo nível, como C e C++, e a segurança de linguagens de programação de alto nível, como Python.
De projetos notáveis como Dropbox e Firefox a WebAssembly e programação embarcada, Rust é amplamente utilizado em todas as áreas de desenvolvimento de software. O Rust oferece suporte de gerenciamento de pacotes pronto para uso por meio do Cargo.
Cargo: O Gerenciador de Pacotes para Rust
Cargo é o gerenciador de pacotes do Rust. Você pode usar o cargo para instalar pacotes de caixas, o registro de pacotes Rust. Além de ser um gerenciador de pacotes que permite pesquisar, instalar e gerenciar pacotes, o cargo também serve como executor de testes, gerador de documentos e sistema de compilação.
Agora que você tem uma visão geral do Rust, vamos dar uma olhada em alguns dos recursos do Rust que o destacam como uma linguagem de programação de sistemas com ampla adoção.
Mensagens de erro úteis
Como um programador iniciante, você encontrará erros e gastará uma quantidade significativa de tempo depurando seu código. Você usará as mensagens de erro e os avisos fornecidos pelo compilador para corrigir esses problemas. E mensagens úteis podem ajudá-lo a depurar mais rapidamente.
Um exemplo de mensagem de erro
Quando seu código não compila com sucesso, o Rust fornece mensagens de erro úteis que fornecem explicações sobre o que precisa ser corrigido em seu código e onde.
Neste exemplo, a variável num2 é definida dentro da função inner(). É, portanto, limitado ao escopo da função. Se você tentar acessá-lo fora da função, o compilador lançará um erro:
fn main() {
let num1 = 10;
fn inner(){
let num2 = 9;
}
println!("The value of num2 is: {}", num2);
}
E a mensagem de erro fornece informações sobre o que precisa ser corrigido.
error[E0425]: cannot find value `num2` in this scope
--> src/main.rs:6:42
|
6 | println!("The value of num2 is: {}", num2);
| ^^^^ help: a local variable with a similar name exists: `num1`
Avisos durante a compilação
O compilador também fornece avisos úteis sobre problemas em seu código. Quando você define variáveis, mas nunca as usa no restante do programa, o Rust apresenta uma mensagem de aviso, conforme mostrado.
fn main() {
let num1 = 10;
let num2 = 9;
println!("The value of num1 is: {}", num1);
}
Aqui, a variável num2 é declarada, mas nunca usada.
warning: unused variable: `num2` --> src/main.rs:3:9 | 3 | let num2 = 9; | ^^^^ help: if this is intentional, prefix it with an underscore: `_num2` |
Linguagem Fortemente Tipada
Outra razão pela qual você deve usar o Rust para seus projetos de desenvolvimento é seu sistema de tipos. Rust é uma linguagem fortemente tipada, o que significa que não suporta coerção de tipo. Coerção de tipo é quando um idioma pode converter implicitamente um valor em um tipo de dados para outro.
Por exemplo, o código Python na célula de código a seguir será executado sem erros. Isso ocorre porque, em Python, um número diferente de zero tem um valor verdadeiro de True e, portanto, a instrução if é executada sem erros — mesmo que o número 10 seja um número inteiro — e não um booleano.
num1 = 10
if num1:
num2 = 9
print(f"num2 is {num2}")
# Output: num2 is 9
Por outro lado, Rust não coage tipos. Portanto, o código a seguir gerará um erro:
fn main() {
let num1 = 10;
if num1{
let num2 = 9;
}
}
O erro relata uma incompatibilidade de tipo, onde um booleano era esperado e um número inteiro foi encontrado.
error[E0308]: mismatched types
--> src/main.rs:3:8
|
3 | if num1{
| ^^^^ expected `bool`, found integer
Segurança de memória
A segurança da memória é outro recurso do Rust que o torna atraente para os programadores. Tentaremos fornecer uma visão geral superficial de como isso funciona.
Variáveis devem ser inicializadas antes de serem usadas
No Rust, todas as variáveis devem ser inicializadas antes de serem usadas. Em linguagens como C, o seguinte código onde num não é inicializado irá compilar e rodar sem erros. O valor da variável não inicializada é algum valor de lixo.
#include <stdio.h>
int main(void) {
int num;
printf("The value of num is %d", num);
return 0;
}
// Output: The value of num is 0
Se você tentar fazer algo semelhante no Rust, encontrará um erro de tempo de compilação. Rust, portanto, não tem noção de coleta de lixo.
fn main() {
let num:i32;
println!("The value of num is: {}",num);
}
error[E0381]: used binding `num` isn't initialized
--> src/main.rs:3:40
|
2 | let num:i32;
| --- binding declared here but left uninitialized
3 | println!("The value of num is: {}",num);
| ^^^ `num` used here but it isn't initialized
|
Segurança de memória em tempo de compilação
Rust garante a segurança da memória em tempo de compilação. Vamos dar um exemplo simples. Aqui, mesmo que a instrução condicional if tenha um valor booleano true, o que significa que o valor de num sempre será 100, obtemos um erro quando tentamos imprimir o valor de num.
fn main() {
let num:i32;
if true{
num = 100;
}
println!("The value of num is: {}", num);
}
Isso ocorre porque a avaliação condicional ocorre em tempo de execução e o compilador não poderá garantir que num tenha um valor em tempo de compilação.
error[E0381]: used binding `num` is possibly-uninitialized
--> src/main.rs:6:41
|
2 | let num:i32;
| --- binding declared here but left uninitialized
3 | if true{
| ---- if this `if` condition is `false`, `num` is not initialized
4 | num = 100;
5 | }
| - an `else` arm might be missing here, initializing `num`
6 | println!("The value of num is: {}", num);
| ^^^ `num` used here but it is possibly-uninitialized
Se você olhar mais de perto a mensagem de erro, verá que com uma instrução else, podemos garantir que num terá um valor. Portanto, o código a seguir será executado sem erros. Porque dessa forma, o compilador pode determinar que num terá um valor – no momento da compilação – para que não haja erros.
fn main() {
let num:i32;
if true{
num = 100;
}
else{
num = 50;
}
println!("The value of num is: {}", num);
}
The value of num is: 100
Imutabilidade das Variáveis
Também é útil observar que as variáveis no Rust são imutáveis por padrão. Isso significa que, como desenvolvedor, você não precisa se preocupar em sobrescrever acidentalmente o valor de uma variável específica. Aqui está um exemplo:
fn main() {
let num1 = 10;
num1 = 5;
println!("The value of num1 is: {}", num1);
}
Como num1 é inicializado com 10, ao tentar atribuir a ele um valor de 5, você recebe uma mensagem de erro que diz ‘não é possível atribuir duas vezes à variável imutável num1’.
error[E0384]: cannot assign twice to immutable variable `num1` --> src/main.rs:3:5 | 2 | let num1 = 10; | ---- | | | first assignment to `num1` | help: consider making this binding mutable: `mut num1` 3 | num1 = 5; | ^^^^^^^^ cannot assign twice to immutable variable
Propriedade e empréstimo
A propriedade garante a segurança da memória. Funcionalmente, a propriedade no Rust pode ser resumida da seguinte forma:
Todo objeto deve ter um e apenas um proprietário. Se o proprietário sair do escopo, o objeto será descartado.
Vamos dar um exemplo simples. Aqui, inicializamos uma string str1 e então movemos seu valor para str2. Como qualquer objeto pode ter apenas um proprietário, o objeto str1 é descartado assim que seu valor é movido para str2.
fn main() {
let str1 = String::from("Rust");
let str2 = str1;
println!("The value of str1 is: {}", str1);
}
error[E0382]: borrow of moved value: `str1`
--> src/main.rs:4:42
|
2 | let str1 = String::from("Rust");
| ---- move occurs because `str1` has type `String`, which does not implement the `Copy` trait
3 | let str2 = str1;
| ---- value moved here
4 | println!("The value of str1 is: {}", str1);
| ^^^^ value borrowed here after move
Embora isso pareça intuitivo, para entender e avaliar melhor como funciona a propriedade, é útil aprender os conceitos de empréstimo e referências.
Desenvolvimento rápido
Até agora, discutimos vários recursos úteis da linguagem de programação Rust. Para revisar alguns:
- Rust é otimizado para velocidade e segurança.
- Ele vem com uma ferramenta de gerenciamento de pacotes integrada e constrói um sistema.
- Ele também possui uma rica biblioteca padrão.
Em essência, o Rust oferece tudo o que um desenvolvedor pode pedir. Portanto, com o Rust, você pode desenvolver aplicativos rapidamente com depuração mínima e compilações mais rápidas.
Desenvolvimento multiplataforma
Com o Rust, você pode optar por desenvolver em uma plataforma de sua escolha. Rust suporta as plataformas mais comuns: Linux, MacOS e Windows.
O desenvolvimento de aplicativos geralmente é fácil, pois você pode compilar o código-fonte do Rust em um executável sem depender de outras ferramentas de compilação e compiladores externos.
Uma comunidade de apoio ajuda muito a simplificar sua jornada de aprendizado. Rust tem uma enorme base de usuários que só cresce a cada ano que passa.
A popularidade do Rust na pesquisa de desenvolvedores do StackOverflow indica que há uma grande comunidade de usuários, com muitos desenvolvedores experientes dispostos a compartilhar seus conhecimentos e experiências.
Além da documentação oficial, há também um site de documentação gerado pelo usuário e um fórum de discussão. Você também pode verificar o subreddit do Rust e os grupos do LinkedIn para discussões relevantes.
Recursos de aprendizado para começar a usar o Rust
Esta seção lista alguns recursos úteis para ajudá-lo a começar a usar o Rust. Esta não é uma lista exaustiva, mas inclui alguns tutoriais, cursos e livros recomendados para ajudá-lo em sua jornada de aprendizado.
#1. Ferrugem Por Exemplo
O Rust By Example ensinará os fundamentos do Rust e as bibliotecas padrão por meio de uma série de exemplos que você pode codificar em um editor online.
Os tópicos abordados incluem engradados, carga: a ferramenta de gerenciamento de pacotes para Rust, genéricos, características, tratamento de erros e muito mais.
#2. farfalhar
Rustlings é outro recurso de aprendizado oficial para a linguagem de programação Rust. É semelhante ao Rust por exemplo. No entanto, requer que você configure seu ambiente de desenvolvimento local, clone um repositório de exemplo e resolva problemas simples para aprender esses conceitos.
#3. Pista de ferrugem de exercício
O Rust Track on Exercism tem mais de 100 exercícios para ajudá-lo a aprender e testar sua compreensão do Rust. Exercism é uma plataforma gratuita onde você pode ser orientado por programadores experientes, além de codificar seu caminho através dos exercícios.
#4. Ultimate Rust Crash Course
O Ultimate Rust Crash Course ministrado por Nathan Stocks na Udemy abrange o seguinte:
- Fundamentos da programação em Rust
- Sistema modular em Rust
- Tipos de dados e fluxo de controle
- Referência e empréstimo
- Estruturas, características e coleções
#5. Ultimate Rust 2: Conceitos intermediários
Ultimate Rust 2 é um curso de acompanhamento do Ultimate Rust Crash Course e abrange os seguintes tópicos:
- fechamentos
- Iteradores
- Manipulação de erros
- Teste de unidade e integração
- Logging, multithreading e canais
#6. Rust lang: O guia completo para iniciantes 2023
Este curso da Udemy ministrado por Catalin Stefan é um curso abrangente sobre programação Rust. Alguns dos tópicos abordados incluem:
- fundamentos de ferrugem
- Tipos de dados, estruturas de controle
- Funções, características
- Gerenciamento de memória
- Simultaneidade
#7. Rust de programação: desenvolvimento de sistemas rápido e seguro
Programming Rust by O’Reilly é um popular livro de programação Rust que ensina o seguinte:
- Tipos de dados fundamentais
- Propriedade e empréstimo
- programação assíncrona
- Aplicativos multithreading rápidos
- Fechamentos, iteradores
- Coleções
#8. A Linguagem de Programação Rust, 2ª Edição
A Linguagem de Programação Rust é de autoria de colaboradores renomados da comunidade Rust. Este livro cobre tudo o que você precisa saber sobre Rust, incluindo:
- Propriedade e empréstimo
- Genéricos, características
- Ponteiros inteligentes, multithreading
- Testes e tratamento de erros
#9. O Guia Completo de Referência de Programação Rust
O Guia Completo de Referência de Programação Rust da Packt cobre o seguinte:
- Implementando estruturas de dados em Rust
- Escrevendo componentes reutilizáveis e testáveis em Rust
- Projetando projeto de algoritmo de aplicativos multithreaded e
- Aplicações de Rust em WebAssembly, rede e aplicações de linha de comando
#10. Projetos Criativos para Programadores Rust
Se você é um desenvolvedor experiente aprendendo Rust, construir alguns projetos em seu domínio de interesse será suficiente para obter uma boa compreensão da linguagem. Creative Projects for Rust Programmers da Packt é um livro que ensina Rust aplicando-o a projetos como:
- Construindo serviços web Restful
- jogos 2D com
- Desenvolvimento de aplicações web usando o WebAssembly
- Emuladores de linguagem de máquina
- e mais!
Conclusão
Este artigo apresentou uma visão geral do Rust como uma linguagem de programação de sistemas, incluindo recursos como segurança de memória, gerenciamento de pacotes aprimorado e muito mais. Também enumeramos recursos de aprendizado para ajudá-lo a começar a usar o Rust.
Como próximo passo, você pode escolher um ou mais dos recursos de aprendizado mencionados para aprender os fundamentos do Rust. Boa programação Rust!
Você também pode explorar alguns dos melhores provedores de hospedagem de servidores Rust.
