Como aprender a ferrugem sem instalar nenhum software

Um dos recursos mais exclusivos e amados do Rust é seu compilador agressivo que ajuda a garantir a correção e a segurança antes que o programa seja executado. Como resultado, os desenvolvedores da Rust podem escrever programas de alto desempenho, mas seguros. O Rust elimina classes inteiras de erros de programação, especialmente aqueles difíceis de depurar em tempo de execução.

Se você ainda não experimentou, tente! Isso é mágico. Acredito que Rust poderia ser o próximo Java ou Ruby - a linguagem de programação que todos devem aprender no futuro.

No entanto, o aprendizado do Rust normalmente requer que você instale várias ferramentas de linha de comando no seu computador. O compilador Rust é lento porque todo o paradigma Rust está configurado para analisar profundamente o código-fonte e encontrar erros no tempo de compilação, em vez de travar no tempo de execução.

IDEs on-line Rust, como o Rust Playground e REPL.it, são ferramentas simples que não aproveitam ao máximo o ecossistema Rust de destinos e bibliotecas de compiladores de terceiros.

Então você deve estar se perguntando - posso tentar aprender o Rust sem precisar instalar todos esses pacotes de software no meu computador?

Bem, com as ações do GitHub, você pode! Você pode aprender e experimentar o código Rust diretamente no seu navegador. Vamos começar!

O GitHub Actions facilita a automatização de todos os fluxos de trabalho de seu software, agora com CI / CD de classe mundial. Crie, teste e implante seu código diretamente no GitHub. Faça revisões de código, gerenciamento de filiais e triagem de problemas da maneira que você deseja. O código-fonte e as ações do fluxo de trabalho para o exemplo Hello World podem ser encontradas em este repositório do GitHub.

Olá Mundo

Primeiro, crie um novo repositório GitHub e adicione um arquivo de origem Rust. Vamos adicionar um src/main.rs arquivo com o seguinte conteúdo.

fn main() {    println!("Hello, world!");}

Em seguida, volte para a raiz / diretório do repositório GitHub e adicione um Cargo.toml Arquivo. Este arquivo descreve como o sistema de carga Rust deve construir e empacotar nosso projeto.

[package]name = "hello"version = "0.1.0"authors = ["ubuntu"]edition = "2018"[dependencies]

Agora temos um projeto completo de ferrugem. Vamos construir e executá-lo agora.

Ações do Github

Na guia Ações do GitHub, podemos adicionar fluxos de trabalho associados a este projeto. Essas são ações que o Github executa automaticamente quando certos eventos ocorrem, como envio ou confirmação de código. No nosso caso, gostaríamos que o GitHub crie e execute automaticamente nosso main.rse mostre-nos os resultados.

As ações do fluxo de trabalho e seus acionadores de eventos são definidos em yml arquivos sob o .github/workflows diretório. Você pode escrever o seu próprio yml arquivos ou escolha um dos modelos prontos.

Aqui escolhemos o modelo Rust. O GitHub permite editar o arquivo rust.yml antes de fazer o check-in no repositório.

Vamos dar um minuto aqui para explicar como as ações do GitHub funcionam. O padrão rust.yml arquivo diz que

• Sempre que um usuário envia código ou aceita solicitações pull neste repositório, as ações neste rust.yml o fluxo de trabalho será acionado.
• O fluxo de trabalho criará uma máquina virtual executando o sistema operacional Ubuntu mais recente. Neste sistema Ubuntu, ele executará as seguintes etapas.
• Ele fará o checkout do código no master ramo.
• Ele irá executar o cargo build --verbose comando para compilar e construir o código Rust.
• Ele irá executar o cargo test --verbose comando para executar os casos de teste.
• Todas as saídas padrão e de console no sistema Ubuntu dos dois comandos acima serão capturadas pelo GitHub Actions e exibidas na web.

Você pode editar a última linha em rust.yml atuar cargo run, que executa o programa binário compilado. Nosso atualizado rust.yml arquivo é o seguinte.

name: Ruston:  push:    branches: [ master ]  pull_request:    branches: [ master ]jobs:  build:    runs-on: ubuntu-latest    steps:    - uses: actions/checkout@v2    - name: Build      run: cargo build --verbose    - name: Run      run: cargo run

Agora, sempre que você envia o código para este repositório, as ações em rust.yml são executadas. Você pode ver os resultados na guia Ações.

Você pode clicar em um resultado e clicar na guia compilar à esquerda para ver os detalhes. As seções de construção e execução fornecem os detalhes mais relevantes. A seção Executar mostra a impressão bem-sucedida do hello world!

Em seguida, você pode adicionar dependências de terceiros em Cargo.tomle crie aplicativos Rust complexos em main.rs. Toda vez que alguém envia um código, poderemos ver os resultados.

Desenvolvimento Orientado a Testes (TDD)

Obviamente, muito poucos desenvolvedores realmente executam seus programas para imprimir texto no console. o cargo run acima é apenas um show. Na realidade, a maioria dos desenvolvedores escreve funções e casos de teste para essas funções. A tarefa mais frequente após a compilação e construção é executar casos de teste. Vamos ver como é feito.

Crie um novo repositório GitHub e adicione um src/lib.rs arquivo abaixo. Como você pode ver, ele define uma função Rust e alguns casos de teste. Ele pode ser construído e lançado como um pacote de biblioteca Rust.

pub fn say(s: &str) -> String {  let r = String::from("hello ");  return r + s;}#[cfg(test)]mod tests {  use super::*;    #[test]  fn say_hello() {    let result = say("ssvm");    assert!(result.contains("hello ssvm"));  }}

Então, volte para a raiz / diretório do repositório GitHub e adicione o seguinte Cargo.toml Arquivo.

[package]name = "hello"version = "0.1.0"authors = ["ubuntu"]edition = "2018"[lib]name = "hello_lib"path = "src/lib.rs"crate-type =["cdylib"][dependencies]

Clique na guia Ações e adicione o fluxo de trabalho Rust padrão. Como você se lembra, o fluxo de trabalho Rust padrão termina com cargo test, que é exatamente o que precisamos aqui.

O fluxo de trabalho é executado sempre que um novo código é enviado para este repositório. Você pode clicar em abrir uma construção bem-sucedida e ver a saída das ações de construção e teste.

Qual é o próximo

Agora você pode experimentar seu código Rust e solicitar ao GitHub que construa, teste e execute para você com saídas completas do console, de graça e sem sair do navegador!

Recursos

Sobre o autor

Dr. Michael Yuan é o autor de 5 livros em engenharia de software. Seu último livro Criando aplicativos Blockchain foi publicado por Addison-Wesley em dezembro de 2019. Você pode começar com seu primeiro aplicativo da web descentralizado em 5 minutos usando o BUIDL IDE online (com tutoriais do livro)

Ele também é o CEO da Segundo Estado, uma empresa que se concentra em trazer as tecnologias WebAssembly e Rust para aplicativos em nuvem, blockchain e IA.

Antes do Segundo Estado, o Dr. Yuan colaborou por muito tempo em código aberto na Red Hat, JBoss e Mozilla.

Fora do software, o Dr. Yuan é um pesquisador principal nos Institutos Nacionais de Saúde, com vários prêmios de pesquisa em pesquisas sobre câncer e saúde pública. Ele é PhD em astrofísica pela Universidade do Texas em Austin.