collapse

* Posts Recentes

Desenvolver em Rust com inline em Python por blabla
[22 de Outubro de 2021, 23:47]


A oficina do mestre Dan Gelbart: mecânica e electrónica por blabla
[22 de Outubro de 2021, 23:13]


Identificador Via Verde por KammutierSpule
[19 de Outubro de 2021, 14:33]


Visualizing memory layout of Rust's data types por blabla
[15 de Outubro de 2021, 14:01]


Ligação desconhecida por jm_araujo
[14 de Outubro de 2021, 00:35]


Electrónica em palpos de aranha por SerraCabo
[13 de Outubro de 2021, 15:46]


Pistola de Dessoldar por dropes
[08 de Outubro de 2021, 14:45]


KiCad stable release 5 por KammutierSpule
[06 de Outubro de 2021, 16:00]


Assemblagem de PCBs - JLCPCB por fergas
[06 de Outubro de 2021, 10:12]


Tarifas carta postal Correos.ES por jm_araujo
[05 de Outubro de 2021, 23:16]

Autor Tópico: O porquê que os programadores gostam tanto da linguagem de programação Rust.  (Lida 1341 vezes)

0 Membros e 1 Visitante estão a ver este tópico.

Offline blabla

  • Mini Robot
  • *
  • Mensagens: 69
Boa noite,

Estas são as principais razões pelas quais os programadores que conhecem a linguagem Rust gostam tanto de Rust.

Why Developers Love Rust
https://ibraheem.ca/posts/why-devs-love-rust

Cumprimentos,
João

Offline jm_araujo

  • Mini Robot
  • *
  • Mensagens: 2.783
  • NERD!
Vou ler a ver se descubro a razão :)
Não sou programador (mas programo quando preciso), e sempre que olho para rust não vejo onde está o fascínio, parece apenas "mais uma". Quando tenho de  olhar para C, PHP, JS e agora Rust, parecem-me todas irmãs (sendo PHP a feia e com problemas de desenvolvimento 😂, é cada idiotice). E apesar que Rust poder ter as suas vantagens, a sensação que me fica é que só se aplica a quem trabalha a sério em programação, gajos como eu que pego em código só quando calha, e sempre com o Stackoverflow na janela ao lado, não vejo onde está o fascínio, e não fico com vontade de me enterrar nela.

 A única linguagem "recente" que me fascinou é mesmo Python. É duma elegância extrema, com meia dúzia de linhas graças às fantásticas bibliotecas que tem faz-se tudo que se consiga imaginar. É quase nostálgico, faz-me voltar aos tempos que era tudo mais "BASICo" ;). Acho até engraçado que a maior implicação é com a identação como parte da linguagem, mas depois passam o código nas outras linguagens por um beautifier e anda tudo a discutir se usam formato K&R, Stoustup, Allman, linux ou Java! Haja pachorra :D !!!

Offline blabla

  • Mini Robot
  • *
  • Mensagens: 69
jm_araujo,
se depois de leres gostares do que viste em Rust e quiseres aprender a linguagem, permite-me que te sugira o seguinte guia com informação de Rust que eu tenho estado a fazer.

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

Obrigado,

Cumprimentos,
João Nuno Carvalho

Offline KammutierSpule

  • Mini Robot
  • *
  • Mensagens: 1.448
Obrigado pela partilha, não li (só um pouco), mas foi talvez o primeiro link que abri sobre Rust, apesar da "divulgacao" pelas redes sociais.

Tenho ouvido falar que já tem sido usado em sistemas embutidos.

Pessoalmente, estou a sentir que vou ficar "burro velho" com o C/C++, pelo menos no que diz respeito à programação de microcontroladores.
Dependerá muito também do que os fabricantes venham a suportar.

Ao nível de linguagem, eu tive uma educação (auto-didata e escolar) que começa por aprender assembly.

Em recursos muito limitados como os microcontroladores, apesar de cada vez mais terem maiores capacidades, quem está a desenvolver código que implique processamento de dados e restrições temporais, importa saber a complexidade do que o compilador está a gerar.

Ora a linguagem C é quase o que poderiamos considerar um Assembly "alto nivel", onde facilmente se percebe que instruçoes estarão a ser geradas.

Vejamos o exemplo retirado ai do site:

Código em C

Código: [Seleccione]
int squares[10];
for (int i = 0; i < 10; ++i)
{
  squares[i] = i * i;
}


Código em Rust
Código: [Seleccione]
let squares: Vec<_> = (0..10).map(|i| i * i).collect();
Saber que instruçoes estarão a ser geradas olhando para o codigo em C é muito facil.

A verdade é que não conheço nada de Rust.. mas olhando para aquilo "Vec" .. "map()", "collect()" que raio de complexidade é que estará por ali envolvida?
São funções? São optimizadas? são sempre optimizadas? a complexidade é diferente em que casos?

No caso do codigo em C, agora comentado:

Código: [Seleccione]
int squares[10]; // nenhuma intrução
for (int i = 0; i < 10; ++i) // 1 atribuição, 1 comparação, 1 soma
{
  squares[i] = i * i; // squares[i] 1 multiplicação para calculo do ponteiro + 1 atribuição, i * i 1 multiplicação
} // 1 jump
« Última modificação: 20 de Janeiro de 2021, 08:43 por KammutierSpule »

Offline blabla

  • Mini Robot
  • *
  • Mensagens: 69
Bom dia KammutierSpule,

No caso do código do exemplo, o código gerado por um exemplo e pelo outro não é muito diferente, apesar de um usar um array fixo e o outro usar um Vec (Vector) que é um array variável por genérico por template T em que tem um pointer (no stack) para o heap com um array contendo os elementos e dois  inteiros (também no stack) um contendo o length e outro contendo a capacidade total mesmo que não seja totalmente usada, que neste caso é totalmente a usada, pois é criado com o tamanho certo.
O Rust segue o mesmo princípio do C++ de Zero Cost Abstractions, em que as abstrações que ele possa ter, não têm um custo estra apesar de poderem ser de mais alto nível.

Contudo esse exemplo de comparação de C para Rust só serve para mostrar que se podem usar abstrações de mais alto nível tal como no C++ se pode fazer exatamente o mesmo se bem que escrevendo mais código, mas que gera igualmente código eficiente.
Mas em Rust o mesmo exemplo poderia ser feito da seguinte forma que é mais simples tal como o exemplo de C.

Código C

Código: [Seleccione]
int squares[10];
for (int i = 0; i < 10; ++i)
{
  squares[i] = i * i;
}


Código Rust:

Código: [Seleccione]
let square: [i32; 10];
for i in 0..10 {
    squares[i] = i * i;
}

Nota: O código executável Rust em geral já é mais rápido do que o de C e só fica em segundo para o código gerado por C++ e a diferença é muito pequena. Existem benchmarks em que o o Rust ganha ao C++. Seja como for ninguém iria querer manter esse código em C++ pois para bater o Rust tem de usar todos os truques possíveis e imaginários do C++ e isso entra nas partes mais escuras da linguagem C++ que já de si é muito complexa :-D

Por ultimo, uma parte muito boa do desenvolvimento de Rust para sistemas embebidos ou embarcados, é que este não está a ser feito pelos fabricantes mas sim pela comunidade e por isso o código que está a ser desenvolvido para microcontroladores é muito similar independente da família ou fabricante para o qual se está a desenvolver e as HAL desenvolvidas podem ser usadas entre diferentes fabricantes de modo muito similar. Já existe suporte para imensas familias de microcontroladores, incluindo tudo da STM32 e a SAM. Mas tal como disse ainda não tenho experiência com o desenvolvimento para microcontroladores em Rust, apesar de ter em C para várias famílias de fabricantes de microcontroladores.

Mas a grande vantagem do Rust, e que também existe para os microcontroladores é que a linguagem trás algumas garantias de segurança e qualidade do código gerado, pois elimina algumas classes de erros que ocorrem em programas escritos em C ou em C++, sem sacrificar a performance. É essa a grande vantagem do Rust.

Só para terem uma ideia e com base nisto o grande programador John Carmack da IDSoft (DOOM e afins) e da empresa de Foguetões, aconselhou o Elon Musk publicamente num Tweet a ele usar o Rust no código do microcontrolador que fica dentro do crânio da pessoa no NeuralLink bem como acho que no software de apoio, por este gerar código muito mais seguro do que C.

Cumprimentos,
João

Offline KammutierSpule

  • Mini Robot
  • *
  • Mensagens: 1.448
Bom dia!

Mas a grande vantagem do Rust, e que também existe para os microcontroladores é que a linguagem trás algumas garantias de segurança e qualidade do código gerado, pois elimina algumas classes de erros que ocorrem em programas escritos em C ou em C++, sem sacrificar a performance.

Queres mostrar alguns exemplos comparativos?

Alguns dos exemplos que vi no site, não achei boa comparação, porque eram "demasiado obvios" que "isto não se faz assim em C"
outros exemplos que vi, também podem ser minimizados com boas praticas de programação.

ainda reparei, mas não analisei de modo a certificar-me, que talvez alguns exemplos dos erros do compilador Rust possam ser activados nos compiladores de C/C++ que convertendo certos warnings, activados como erro.

Depois ainda ha as aplicacoes de analise estatica (e dinamica) de codigo ou normas de codigo como o MISRA C

É verdade que o C/C++ não é um linguagem segura.. mas por isso, é que dá para fazer muitas "coisas periogosas" engraçadas :P

EDIT: obrigado pelas tuas explicaçoes!

Offline blabla

  • Mini Robot
  • *
  • Mensagens: 69
Este link do Why Developers Love Rust, é mesmo um dos links mais claros a explicar as vantagens do Rust sem teres de começar a aprender Rust (por exemplo pelo livro do Rust que está disponível gratuitamente mas tem 513 pág de letra pequena).

As principais vantagens são:
Não podes usar memoria que já libertaste e da qual já não és dono, não podes libertar memoria duas vezes, ex: double free, não tens nunca dangling pointers ou invalid pointers (por exemplo em C++ se tens um pointer para um elemento de um Vec e depois adicionas  um elemento ao Vec e o Vec, por acaso está no limite da capacidade e tem de fazer um resize em que tem de alocar uma novo segmento de memoria e copiar os dados to array antigo para o novo array e libertar o array antigo, o pointer fica invalido pois está a apontar para o array que libertaste mas claro no teu código fora do Vec. Tu se não soubesses como a class do Vec estava implementada, estarias alegremente a usar o pointer e a maior parte das vezes funcionava mas depois numa determinada vez ele fazia-te um resize ao array e tinhas um dangling pointer que teria um comportamento indefinido no teu programa). Outros exemplos é que não existem buffers overruns logo a aplicação é mais resistente a alguns tipos de ataques de hacking.

Em termos de multithreading não existem race conditions pois o compilador apanha esses casos e avisa-te, logo o desenvolvimento e a manutenção são mais seguras, chamam a isso no Rust Fearless Concurrency, pois deixas de ter muitos dos medos habituais associados ao condigo concorrente e paralelo. E neste momento um servidor da AMD tem 64 cores e 128 Threads a correr no hardware literalmente em paralelo, ao mesmo tempo e nem estou a falar que estão no scheduler à vez, logo esse hardware tem de ser aproveitado.

Depois não tens NULL’s e logo desaparecem toda uma classe de problemas que o autor dos NULL’s disse que era one Billion Dollares Problem.

E depois existem muitas outras vantagens que um developer só se apercebe quando já conhece a linguagem e o ecossistema, por exemplo em mais linguagem nenhuma que eu conheça é tão fácil de usar um package que encontre na net (estão centralizados no crates.io), Só tens de adicionar uma linha e o processo é todo automático (faz download, compila o código mesmo o de C ou C++, instala tudo e fica pronto a usar no teu código com uma simples linha de “use  xpto”) e em poucas linguagens é tão fácil de preparar projetos para publicação no repositório único da linguagem e de os publicar. Ora isto favorece que a linguagem cresça por isso é que já existem 53.000 crates (packages) no crates.io .

A linguagem também está muito bem feita em termos da produção da documentação para as tuas API’s ou programa na própria linguagem e em que os próprios exemplos que se coloquem na documentação (ficando no mesmo ficheiro do código) são testados automaticamente para que sejam sempre testes que compilem e funcionem corretamente por exemplo com assert_eq! .

Como tal a documentação das API’s mesmo das de opensource é fantástica quando comparada com as outras linguagens, pois existe os mecanismos e a cultura da documentação.

Por outro lado o compilador é mesmo muito bom, ele dá erros e sugestões fantásticas para a correcção dos erros que nunca vi outro compilador a conseguir dar, basta ver o livro do Rust para ver o tipo de mensagens que ele dá.

O Rust não tem GC e é muito rápido (ficando só em segundo lugar para alguns programas escritos em C++ e optimizados como se não houvesse amanhã) mas em Rust não se necessita de fazer free()’s ou delete apesar de existir a função drop(). Contudo em 99% dos casos não é necessário invoca-la (não se invoca diretamente), é automático, mas sem GC.

Em Rust naturalmente é preferido o Stack ao Heap, logo penso que seja naturalmente um pouco mais rápido também por isso.

A comunidade de Rust também é fantástica a tirar dúvidas da linguagem, da std (standard library) e dos crates (packages).
Existem muito mais coisas que tornam o Rust bom e algo em que dá prazer programar, mas só depois de se começar a programar é que se consegue perceber mais esses detalhes.

As ferramentas para o seu desenvolvimento são todas gratuitas e OpenSource.
Por exemplo usando o Visual Studio Code existe um plugin muito bo que é o Rust Analyzer e ferramentas como o cargo também centralizam muito das necessidades durante o desenvolvimento com a linguagem.

Rust é uma linguagem feita pela comunidade para a comunidade, completamente Open Source e que trás coisas novas, alguma lufada de ar fresco.

Seja como for, o link que eu indiquei em cima para o guia que eu fiz tem a minha melhor tentativa de colocar a documentação de Rust o mais agregada possível em várias áreas do seu desenvolvimento.

Cumprimentos,
João 

Offline blabla

  • Mini Robot
  • *
  • Mensagens: 69
Gostaria só de adicionar uma pequena nota.

Eu não acho que a melhor abordagem para quem pretende aprender Rust seja a de começar logo em microcontroladores, penso que primeiro deve-se começar num PC, com Windows, Linux ou Mac e só depois ir para os microcontroladores, mesmo porque os microcontroladores não tem a STD (standard Library) pois não cabia dentro de muitos deles.
Por isso digo-vos para seguirem mesmo o meu guia que facilita muito.

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

Contudo para os aventureiros que pretendem dar o corpo ao manifesto e encher o peito de ar em direção às balas e aos problemas, este pode ser uma forma divertida de aprender.
Quem é que não tem um Arduino Uno em casa :-D

How to run Rust on Arduino Uno
https://dev.to/creativcoder/how-to-run-rust-on-arduino-uno-40c0

Vejam a diretoria de exemplos dentro diretoria das Boards e vejam os exemplos na documentação dentro de cada estrutura nos métodos e funções.

avr-hal
https://github.com/Rahix/avr-hal

Mas façam um favor a vocês mesmo e antes de começarem a programar pelo menos leiam isto para perceberem minimamente o código de Rust.

A half-hour to learn Rust
https://fasterthanli.me/articles/a-half-hour-to-learn-rust

Cumprimentos,
João
« Última modificação: 20 de Janeiro de 2021, 16:14 por blabla »

Offline KammutierSpule

  • Mini Robot
  • *
  • Mensagens: 1.448
Obrigado pelas partilhas

Citar
Eu não acho que a melhor abordagem para quem pretende aprender Rust seja a de começar logo em microcontroladores,

Eu so desenvolvo para microcontroladores praticamente, por isso não tenho aprendido outras linguagens.
Devia ter aprendido Python? Devia aprender Rust?
De momento com a minha disponibildiade, só irei aprender caso o projecto que tenha de trabalhar necessite.
Porque se não, até quem sabe que a linguagem passa de moda ou .. existem tantas que não é possivel dominar todas... e passo a vida a aprender linguagens só porque sim?

Vou esperar para ver o que aparece futuramente de projectos que usem a linguagem.


Citar
Não podes usar memoria que já libertaste e da qual já não és dono, não podes libertar memoria duas vezes, ex: double free, não tens nunca dangling pointers ou invalid pointers (por exemplo em C++ se tens um pointer para um elemento de um Vec e depois adicionas  um elemento ao Vec e o Vec, por acaso está no limite da capacidade e tem de fazer um resize em que tem de alocar uma novo segmento de memoria e copiar os dados to array antigo para o novo array e libertar o array antigo, o pointer fica invalido pois está a apontar para o array que libertaste mas claro no teu código fora do Vec. Tu se não soubesses como a class do Vec estava implementada, estarias alegremente a usar o pointer e a maior parte das vezes funcionava mas depois numa determinada vez ele fazia-te um resize ao array e tinhas um dangling pointer que teria um comportamento indefinido no teu programa).

Entendo, mas estes exemplos entram nas "más práticas do uso da linguagem C/C++"
Os nullpointer, não estou por dentro da área.. mas ha qualquer coisa nova no C++ para ajudar a resolver isso.
e os novos "smart pointers", mas não sei como se comparam.

Offline blabla

  • Mini Robot
  • *
  • Mensagens: 69
@KammutierSpule – Bom dia, aqui tens um bom exemplo de Zero Cost abstractions em Rust:

Rust zero cost abstractions in action
https://idursun.com/posts/rust_zero_cost_abstractions_in_action/

Cumprimentos,
João