Como aprender a ferrugem sem instalar nenhum software


Neste artigo, aprenderemos como usar as ações do GitHub para aprender Rust no seu navegador da web. Vamos codificar, construir, testar, executar e liberar tudo a partir de uma página da web. Nenhum software necessário!

Rust é uma das linguagens de programação mais populares atualmente. Alpha geeks adoro. É o Stackoverflow linguagem de programação mais amada nos últimos 4 anos seguidos.

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!");
}
O arquivo src / main.rs

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]
O arquivo Cargo.toml no diretório raiz do repositório

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.

O modelo de fluxo de trabalho Rust nas Ações do GitHub

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

O modelo de ações Rust padrão. Você pode editá-lo ao seu gosto.

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: Rust

on:
  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
Alteramos a última linha do modelo Rust padrão para corrida de carga

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.

Cada push no repositório GitHub acionará as ações a serem executadas

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!

A ação Executar mostra Hello World! impresso para o console!

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"));
  }
}
O arquivo src / lib.rs

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.

As ações padrão do fluxo de trabalho Rust são 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.

As ações do Github criam e testam seu programa Rust

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.



Fonte

Leave a Reply

Your email address will not be published. Required fields are marked *