Why Rust makes you feel like a GENIUS?

[blabla]

Bom dia a todos,

Muitos de nós que já entraram no comboio do Rust, sabem que o que está descrito neste vídeo é realmente verdade, mas eu nunca tinha visto todos estes pontos a serem tão bem explicados, de forma tão clara, com exemplos tão simples e diretos, tão "down to earth". Estes motivos, de facto explicam o porquê que Rust é considerado no stack overflow, por quem já aprendeu Rust, como a linguagem de programação mais amada nos últimos 6 anos consecutivos.

Rust makes you feel like a GENIUS




Por tudo isto sugiro-vos que deem uma oportunidade ao Rust e que tentem aprender Rust e depois julguem por vocês próprios, felizmente em Rust muitos dos recursos de Rust são completamente gratuitos e como tal acessíveis a todos.

Dentro dos meus diferentes guias, eu mantenho um guia de Rust, Ele lista muitos desses recursos gratuitos e a ordem inicial pela qual eu acredito que eles devem ser estudados. Convido-vos a usarem esse meu pequeno guia:

How to learn modern Rust
https://github.com/joaocarvalhoopen/How_to_learn_modern_Rust


Contudo Rust é extenso e como tal para aprender Rust é uma maratona e não 100 metros barreiras. Por isso o Rust também nos faz, paralelamente, muito humildes com tudo aquilo que descobrimos que ainda não sabemos e que ainda temos de aprender, à medida que estamos a fazer a nossa caminhada pelo Rust.

Rust é um mundo, um glorioso mundo novo à espera que nós tomemos a decisão de o aprender.

Eu quando comecei a aprender Rust, já tinha uma enorme experiência de programação de algumas décadas em diversas linguagens. Estou a aprender Rust há praticamente dois anos e posso-vos dizer que ainda sou só um mero "aprendiz de feiticeiro", pois sei que tenho ainda muito, mas mesmo muito que aprender!

Obrigado,

Cumprimentos e votos de um bom dia,
João

[TigPT]

Obrigado por partilhares, fiquei curioso de começar a aprender Rust (já andava mas tem vindo a crescer essa vontade).
A ver se arranjo um bom caso para dar os primeiros passos.

[blabla]

Bom dia @TigPT, em relação a qualquer outra linguagem, eu aconselharia-te a ti que presumo que tenhas uma longa experiência a programar em várias linguagens a fazeres exatamente o que estás a dizer, que é de ter um problema e de o tentar resolver nessa nova linguagem. Mas já tendo feito essa caminhada em Rust, no caso especifico em Rust aconselho-te a começares mesmo por fazeres pequenos programas bazaroucos no inicio e por seguires o meu guia de Rust. Pois Rust é um "bicho" diferente de todas as outras linguagens que eu conheço, a maneira de pensar no inicio é diferente e por isso é que o seguir daqueles recursos que enumero é essencial, tal como ler o livro free de Rust. Essa é a minha sugestão para ti @TigPT e para toda a gente que tem experiência em programação.

Peço-te só que nunca te esqueças que aprender Rust é mais um caminhada Zen ou algo dessa natureza, pois vais sentir que existem sempre mais coisas para aprender em Rust. Normalmente tudo faz sentido, mas podes ainda não saber o suficiente de Rust para perceber algo. Aprender Rust tem de ser considerado como algo Zen pois Rust também testa a tua persistência, contudo depois de saberes o básico, o processo de desenvolvimento em Rust é um dos mais agradáveis de entre quase todas as linguagens que eu conheço, e já conheço algumas. 

Muita gente atualmente está a aprender Rust:

Rust adoption, has nearly quadrupled over the past 24 months, going from 600,000 developers in Q1 2020 to 2.2 million Q1 2022

Developer survey: JavaScript and Python reign, but Rust is rising
https://www.infoworld.com/article/3661248/developer-survey-javascript-and-python-reign-but-rust-is-rising.html

Nota: Como é óbvio podes usar qualquer editor de texto para programares em Rust, muita gente usa o Vim, mas existe um editor que é free e que tem uma excelente integração com o Rust Analyser, que te valida todo o código enquanto estás a editar o código e que te mostra in loco os tipos de dados de retorno de cada expressão. E como tal torna o processo de aprendizagem muito mais simples. Por isso pelo menos para começar recomendo-te o Visual Studio Code com o plugin Rust Analyser. Tens uma secção no meu guia sobre esse tema e inclui plugins para debug e mais umas coisas. Tudo free. Podes ainda ligar o Clippy que é um lint extra para o Rust. As mensagens também aparecem dentro do Visual Studio Code se tiveres o clippy configurado, ou então podes correr o clippy da linha de comando.

Boa sorte na tua aprendizagem de Rust!

Cumprimentos,
João

[TigPT]

Obrigado pelas dicas extra. Quando tiver algo significativo para mostrar, partilho, assim podes criticar o meu código, e ajudar-me a crescer!

[blabla]

@TigPT,terei todo o gosto em ler o teu código e em tentar contribuir de alguma forma para aumentar a rapidez da tua aprendizagem de Rust, tentando dar algum tipo de guidance.

Cumprimentos,
João

[amando96]

Muito bom! Vou ver se meto de lado um tempinho para brincar com Rust 

[TigPT]

Eu tinha um desafio e não encontrava uma ferramenta para resolve-lo exatamente como queria, e achei que seria um bom desafio para aprender Rust.

Quem se quiser juntar nesta jornada é bem-vindo 

https://github.com/tigpt/svbump

[blabla]

Boas @TigPT,

deixo-te aqui alguns apontamentos para começares.

No processamento de argumentos começaste bem, pela forma mais simples e mais direta, mas depois de implementares dessa forma. Vê no

https://crates.io/

a crate com o nome de Clap que permite automatizar o parsing de argumentos de um programa. Ele tem dois modos um de especificação manual e um de argumentos derivados que automatiza o processo mas que ainda não se encontra tão documentado como o método anterior.

Depois as strings em Rust, são Unicode codificação UTF-8, pelo que o seu processamento é um pouco mais complexo pois uma string normal do C, pois pode ter comprimentos diferentes em termos de números de bytes para caracteres diferentes. O tipo de dados normal das strings em Rust é o String contudo o dos argumentos de um programa se não me engano é OSString

https://doc.rust-lang.org/std/ffi/struct.OsString.html 

Podes fazer alguma validações e depois converter  para uma String normal e processar dentro de uma String normal.

Para processar as posições de uma string em Rust tens de começar a interpretar a string do inicio para o fim, pois só assim é que sabes qual é o comprimento de cada carácter.

Depois existe uma forma que não é a mais correta para todas as linguagens possíveis ou caracteres possíveis de algumas linguagens no mundo. Por exemplo se inverteres a ordem da string, e se tiveres os caracteres com acentos como carater separado do carater normal, exemplo "e" com "'" em vez de um único carater o "é", mas para a maior parte dos casos das linguagens europeias (subset das latinas) podes usar a minha pequena lib que implementa a maior parte das funções como

Código: [Seleccione]

Vec<char> e assim já poderás facilmente aceder ao à string como um array de posições sem teres sempre de começar do zero da string, como terias de fazer com iteradores, e com conhecimento ou teste do comprimento de cada carácter. Esta lib pode não ser a melhor do mundo e não é, nem é a mais rápida, mas aconselho-te a começares por ela e depois a fazeres com iteradores em strings normais, numa segunda iteração para uma solução do problema. (O objetivo é aprender Rust, certo?).

Por fim vê coisas como as

Código: [Seleccione]

macros println!(), format!(), write() trait e afins. Vê os derive debug e os

Código: [Seleccione]

:? e afins.

Vais ver que vais fazer isso num instante, a parte mais complicada vai ser o parsing dos parâmetros de entrada.

Nota: Acabo de ver que tens uma gramática e tudo para os semver.

Se vais implementar isso tudo não é um bom projeto para começares, é demasiado complexo para começar a aprender uma linguagem normal, quanto mais uma linguagem com a complexidade do Rust. Ou fazes um subset mais simples ou começa com algo mais simples pois se vais implementar ou usar um parser a complexidade do teu projeto sobe automaticamente para um nível muito maior.

Com Rust tem de no inicio ser sempre baby steps.

E vê os dois vídeos que eu coloquei na outra thread, eles vão te ajudar bastante.

A "lib" (código solto) que eu criei podes encontrar aqui:

SubStrings_Slices_and_Random_String_Access_in_Rust
https://github.com/joaocarvalhoopen/SubStrings_Slices_and_Random_String_Access_in_Rust

no meu repositório do less_fp eu adicionei-lhe dois métodos um find_vec_all() e um find_str_all(), depois quando tiver tempo irei colocar também dentro do link em cima, mas até lá só tens de copiar o código dessas duas funções na declaração do trait e na implementação do métodos. Podes usar os testes para veres como todas as funções do

Código: [Seleccione]

Vec<char> são usadas.

Por fim eu no

Código: [Seleccione]

vec<char> implementei código que faz a normalização da sequencia de caracteres de UTF-8 por isso se a string contiver "e" com "'" vai transformar isso automaticamente num único carater "é", logo mesmo o reverse irá funcionar bem.

Cumprimentos,
João

[blabla]

Se quiseres passar por cima da complexidade do semver podes sempre começar por implementar a tua funcionalidade em cima deste crate. e depois ir descendo de nivel e adicionar mais detalhes e mais customizações.

Mas implementar logo uma gramatica complexa não me parece a melhor solução.

semver
https://crates.io/crates/semver

Cumpriemntos,
João

[TigPT]

Fixe, vou ver. Estava a pensar usar regex mas assim ainda melhor.

[blabla]

Ok @TigPT,

se mesmo assim quiseres fazer do zero, se calhar até consegues, vê estes guias e estas soluções vê por ordem mas no final se quiseres implementar o teu parser usa o Pest pois a tua gramática do semver é complexa. Mas está toda definida no site do semver que tu indicaste.

Writing a Simple Parser in Rust
https://adriann.github.io/rust_parser.html

Pest

Learn to Build a Parser in Rust for Fun and Profit
https://dev.to/pancy/learn-to-build-a-parser-in-rust-for-fun-and-profit-2id5

Site do Pest, onde encontras o book free do Pest e os docs.
Canto superior direito.
https://pest.rs

A thoughtful introduction to the pest parser
https://pest.rs/book/

Cumprimentos,
João

[TigPT]

Enquanto procurava documentação para implementar o que queria, encontrei algo que faz exatamente o que procuro, o que me deixou feliz e triste ao mesmo tempo.

https://lib.rs/crates/bump-bin

Acho que para já vou usar o bump-bin para avançar com o projecto, mas de qualquer das formas para aprender um bocadinho de rust vou tentar a minha implementação de algo semelhante

[TigPT]

na verdade não faz exatamente o que quero mas consigo lá chegar com pipes

[blabla]

@TigPT,

Dá uma vista de olhos na lib do Pest para fazer parsers em Rust a partir de gramáticas, mesmo que seja só pela piada da coisa :-)
À primeira vista parece-me uma lib muito simples de usar.
Eu no passado, já tinha ouvido falar muito bem do Pest mas nunca tinha olhado para código que usa-se Pest e ontem vi e parece-me algo muito simpático!
Os links estão em cima.

Cumprimentos,
João