LusoRobótica - Robótica em Português
Software => Software e Programação => Tópico iniciado por: blabla em 26 de Maio de 2022, 11:27
-
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
https://www.youtube.com/watch?v=0rJ94rbdteE (https://www.youtube.com/watch?v=0rJ94rbdteE)
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 (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
-
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.
-
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 (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
-
Obrigado pelas dicas extra. Quando tiver algo significativo para mostrar, partilho, assim podes criticar o meu código, e ajudar-me a crescer!
-
@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
-
Muito bom! Vou ver se meto de lado um tempinho para brincar com Rust :)
-
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
-
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/ (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 (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 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 macros println!(), format!(), write() trait e afins.
Vê os derive debug e os :?
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 (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 Vec<char>
são usadas.
Por fim eu no 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
-
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 (https://crates.io/crates/semver)
Cumpriemntos,
João
-
Fixe, vou ver. Estava a pensar usar regex mas assim ainda melhor.
-
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 (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 (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 (https://pest.rs)
A thoughtful introduction to the pest parser
https://pest.rs/book/ (https://pest.rs/book/)
Cumprimentos,
João
-
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 :)
-
na verdade não faz exatamente o que quero mas consigo lá chegar com pipes
-
@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