Développez votre première application en Rust

Développez votre première application en Rust

Quelques minutes suffisent !

50

Développez votre première application en Rust

Lorsque l'on parle d'apprendre à développer, il est souvent question du trio à tout faire HTML/CSS/JS, pensé pour le web. Parfois de langages plus classiques comme C#, Java, Python ou Ruby. Plus rarement de langages bas niveau tels que C(++), Go ou Rust. Penchons-nous sur ce dernier.

Ce week-end a débuté la semaine du code. Une initiative européenne visant à faire découvrir, notamment aux plus jeunes, le développement logiciel. Comme Thierry Breton, nous aurions pu faire des blagues sur le nom de C++, Java et Python. On aurait aussi pu vous apprendre à développer une première application... mais c'est déjà fait.

Si vous nous suivez depuis quelques années, vous savez le faire avec une interface graphique, du Node.js pour un serveur web ou une application packagée, suivre l'actualité avec un script Python et de la synthèse vocale, créer votre extension de navigateur, une fonction en ligne via l'approche serverless ou une PWA en puissance.

Le tout avec un zeste de stockage objet via votre propre serveur MinIO. Bref, grâce à nous, vous êtes déjà full-stack ! Dès lors, que faire de plus ? Vous apprendre à devenir des dieux de l'Unreal Engine et du ray tracing ? Tout comprendre de la comparaison trilatérale introduite dans C++ 20 ? Non, il fallait regarder vers le futur, le vrai.

Nous avons donc décidé de vous apprendre à développer dans un langage mêlant simplicité et efficacité, tout en étant parfois très différent de ce que vous avez déjà vu ailleurs, multiplateforme et open source : Rust. Si vous faites partie de ceux qui pensent que développer dans un langage dit de bas niveau est compliqué, que cela demande des outils de folie, finissons-en avec vos idées reçues dans ce premier article.

On passe tout de suite à la pratique

Ainsi, plutôt que de commencer en vous expliquant ce qu'est Rust, en vous chantant ses louanges pour justifier notre choix du jour, mettons-nous plutôt directement au travail. Vous verrez, une fois les différents éléments de base installés et sans rien faire de bien compliqué... tout sera vite bouclé (sauf si vous partez manger une raclette).

  • L'installation via rustup

Première étape : télécharger Rust ou plutôt rustup. Il s'agit d'une application permettant d'installer (et de mettre à jour) simplement les différents outils nécessaires, proposés pour Linux, macOS et Windows.

Tout sera configuré automatiquement ou presque. C'est ainsi que l'on va récupérer Cargo, un élément central dans l'écosystème Rust, étant à la fois utilisé pour la compilation, la gestion de paquets ou encore la publication (nous y reviendrons). Pour savoir comment procéder pour votre système, rendez-vous sur cette page.

Lorsque le gestionnaire de paquets de votre système permet l'installation de rustup, vous pouvez l'utiliser. S'il est basé sur UNIX (Linux, macOS), un script global est également à votre disposition :

curl https://sh.rustup.rs -sSf | sh

Pour le sous-système Linux de Windows 10 (WSL), l'équipe conseille la commande suivante :

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Si vous préférez récupérer manuellement le paquet d'installation de votre choix, ça se passe par ici

Sous Linux il faudra penser à installer les éléments de base pour le développement et la compilation. Dans les distributions dérivées de Debian, cela passe par la commande suivante :

sudo apt update && sudo apt install build-essential

Sous Windows il faut obligatoirement récupérer la dernière version en date de rustup puis l'exécuter. Une étape préalable est là aussi nécessaire : l'installation des outils de développement Visual C++ (Build Tools). Le SDK Windows 10 et le pack de langue anglaise doivent être sélectionnés, soit 4,85 Go tout de même :

  • Installation des Visual C++ Build Tools
  • Installation des Visual C++ Build Tools
  • Installation des Visual C++ Build Tools
  • Installation des Visual C++ Build Tools

C'est la seule étape qui peut éventuellement prendre du temps. Si vous ne voulez pas en passer par là, utilisez le sous-système Linux, un petit serveur ou même un Raspberry Pi. Pour simplement tester du code, sans le compiler localement, l'équipe de Rust met à votre disposition un bac à sable en ligne.

Dans la pratique, rustup vérifie que les pré-requis sont en place, récupère et installe les outils dans une version adaptée à votre système et ne vous posera que peu de questions. Dans la procédure personnalisée, vous pourrez choisir le dossier (path) d'installation, le canal utilisé (stable, beta, nightly) mais aussi entre trois profils d'installation : par défaut, minimale ou complète. Laissez les paramètres initiaux (voir ci-dessous).

Notez aussi la notion de « host triple », il s'agit de la suite d'outils qui sera installée pour l'hôte détecté. Dans le cas de Windows, ce sont ceux de Visual C++(MSVC) par défaut. Vous pouvez également opter pour GCC si vous le préférez, la méthode à suivre est décrite dans la documentation. Comme nous le verrons tout au long de ce dossier, la documentation complète et plutôt claire de l'écosystème Rust est d'ailleurs l'une de ses forces.

Vous pouvez alors ajouter le support de l'auto-complétion, disponible pour plusieurs interpréteurs de commandes : Bash, Fish, PowerShell ou Zsh. Une fois la procédure terminée, pensez à fermer puis rouvrir votre terminal. 

Installation Rustup Ubuntu WSLInstallation Rustup Ubuntu WSLL'installation dans le sous-système Linux (WSL), elle sera similaire sous macOS et Windows

Pour mettre à jour les composants de Rust, rien de plus simple :

rustup update
  • Hello, World!

Pour vous montrer à quel point compiler votre première application Rust est simple, nous allons le faire en quelques commandes seulement. Attention, cela va aller très vite :

cargo new hello-nxi
cd hello-nxi
cargo run

Et voilà ! Vous avez créé, compilé et exécuté votre première application Rust. L'exécutable se trouve dans le dossier target/debug. Vous pouvez le compiler en version de production en précisant un argument :

cargo run --release

Il sera alors généré dans une version plus optimisée dans le dossier target/release que vous pourrez librement distribuer. Vous pouvez simplement compiler l'application sans la lancer en utilisant la commande cargo build. Si vous disposez d'un gestionnaire de versions (VCS) comme Git d'installé, un dépôt sera automatiquement initialisé. Si vous ne voulez pas que ce soit le cas ajoutez --VCS none à la création du projet (cargo new).

Point intéressant, l'application n'a pas la même taille sur tous les systèmes. Par exemple celle générée sous Windows 10 (hors WSL) se contente de 150 ko, contre 3 Mo pour sa version Linux. Bien que les améliorations aient déjà été nombreuses depuis les premières critiques sur ce point, Rust continue d'évoluer au fil des versions.

Il existe quelques astuces pour réduire la taille du fichier généré si cela vous pose souci. De la « cross compilation » est possible, mais encore un peu complexe à mettre en place à ce stade. Nous y reviendrons plus tard.

Premières modifications et création d'une macro

On aurait pu s'arrêter là, mais allons tout de même un peu plus loin, en commençant par vous expliquer ce qui s'est passé. À la racine du projet, un fichier Cargo.toml a été créé. Son extension indique qu'il utilise le format TOML.  Il s'agit du fichier de configuration (ou manifeste) de votre application. Si vous l'éditez, vous verrez son nom, celui de l'auteur, sa version, l'édition de Rust (2018) et un emplacement pour ses dépendances. Nous en reparlerons.

Puis il y a le dossier src, contenant le code source de l'application. Il se compose seulement d'un fichier main.rs pour le moment. Vous pouvez d'ailleurs l'utiliser directement avec le compilateur rustc sans passer par Cargo :

rustc src/main.rs

Cela va créer un exécutable nommé main à la racine (supprimez-le ensuite). Ouvrons le projet, dans notre cas avec Visual Studio Code, mais vous pouvez lui préférer Atom, Brackets, Notepad++ ou encore Sublime Text. Nombreux sont d'ailleurs les environnements de développement (IDE) et éditeurs disposant d'un support natif ou d'un plugin pour Rust (et TOML).  Même Emacs, nano (depuis la version 2.6.1) et vim ! Pensez à les installer.

Comme nous utilisons le sous-système Linux de Windows 10, Visual Studio Code a un avantage : il peut être utilisé pour développer depuis le système hôte via son dispositif d'accès distant aux données. Pour cela, il suffit de le lancer comme depuis n'importe quelle plateforme, il installera son serveur la première fois :

code .

Le code de départ est assez simple, se composant d'une fonction main() affichant le classique « Hello, World ! » :

Rust Hello World Visual Studio Code Remote WSL

Il utilise pour cela une première spécificité de rust : les macros. Il s'agit de sorte de « super fonctions » distinguées par un point d'exclamation à la fin de leur nom. Elles sont « étendues » au sein du code source avant la phase de compilation plutôt qu'à l'exécution, entre autres spécificités intéressantes.

Dans le cas présent, println!() permet d'afficher du texte (string literal) pouvant contenir des valeurs ou même des expressions positionnées via des accolades {}. Il le fait suivre d'un saut de ligne contrairement à print!().

Par exemple cette commande ne poserait aucun problème et affichera « Hello, World 42! » :

println!("{}, {crowd} {1}!", "Hello", 2*21, crowd ="World");

On peut adapter le comportement des macros selon la façon dont elles sont appelées. Pour le voir, ajoutons-en une au début de notre code, hors de la fonction principale. Elle sera nommée customPrint :

macro_rules! customPrint {
    ()=> {
      println!("Hello, World!");
    };

    ($dest:expr)=> {
      println!("Hello, {}!", $dest);
    };

    ($act:expr => $dest:expr)=> {
      println!("{} for {}!", $act, $dest);
    };
}

Elle pourra agir de trois manières différentes. Soit l'utilisateur n'utilise aucune expression dans son appel et le message « Hello, World! » sera affiché. S'il ajoute une simple expression, le texte sera personnalisé avec son contenu. S'il utilise la forme spécifique « Action => Destinataire » et les deux termes seront personnalisés.

Si vous compilez ce code, tout fonctionnera comme avant, mais vous aurez un avertissement du compilateur vous indiquant qu'elles ne sont pas utilisées. On remercie ici l'outil clippy de Rust qui analyse le code et donne des conseils au développeur. Par exemple, s'il ne suit pas la convention pour le nom d'une fonction.

Vous pouvez d'ailleurs le lancer manuellement hors d'une compilation :

cargo clippy

D'autres outils sont installés dans la configuration de base de Rust via rustup comme cargo fmt qui permet de formater correctement vos fichiers ou cargo fix pour corriger automatiquement certains problèmes.

Pour corriger l'alerte, on ajoute le code suivant à main() qui exploite les possibilités de notre macro :

customPrint!();
customPrint!("You");
customPrint!("Hurrah"=> "Next INpact");

Comme prévu, trois messages seront affichés les uns à la suite des autres :

Rust Hello MacroRust Hello Macro
L'alerte affichée quand notre macro n'est pas exploitée, puis le résultat final

Gestion de paquets et dépendances 

Bien qu'il s'agisse d'un langage bas niveau, Rust vient avec des outils permettant une gestion « moderne ». C'est notamment le cas de la distribution de paquets, inspirée de ce que l'on trouve avec npm pour Node.js ou en Python avec PyPi par exemple. Chacun peut créer les siens et les mettre à disposition de tous.

Dans l'écosystème Rust, on parle de Crates, qui viennent compléter les bibliothèques de base du langage. Ils sont référencés sur Crates.io et peuvent être ajoutés au sein du projet simplement en ajoutant leur nom et version à la liste des dépendances du manifeste. Notez qu'un registre alternatif existe : Lib.rs.

Par exemple, le crate num_cpus permet de connaître le nombre de cœurs du processeur de la machine. Pour l'utiliser dans sa dernière version, on ajoute cette ligne dans la section dependencies du manifeste Cargo.toml :

num_cpus ="*"

On peut également utiliser un numéro de version précis ou d'autres indications. Une fois le manifeste enregistré, num_cpus est directement exploitable dans notre code. Lors de la prochaine compilation, les fichiers nécessaires seront téléchargés et ajoutés au projet. Par exemple, pour afficher le nombre de cœurs physiques du processeur de la machine et le nombre de threads qu'il peut gérer, on ajoute ces deux lignes dans la fonction main() :

println!("CPU Cores : {}", num_cpus::get_physical());
println!("CPU Threads : {}", num_cpus::get());

Fonction, valeur de retour et déstructuration de tuple

Pour rendre le défi un peu plus intéressant, on peut utiliser une fonction pour renvoyer directement les valeurs à afficher. Ce n'est pas très utile, mais permet de mettre en avant quelques fonctionnalités de Rust.

On ajoute pour cela une fonction dans main.rs. En Rust, sa position importe peu. 

fn get_cpu_count()-> (usize, usize)
{
(num_cpus::get(), num_cpus::get_physical())
}

Si vous avez déjà goûté à d'autres langages, vous aurez compris que get_cpu_count() renvoie un tuple. Il s'agit d'un groupement de valeurs très flexible puisqu'il n'a pas de taille fixe et peut être composé de différents types. Ici, il s'agit de deux entiers non signés usize, puisque c'est le type de valeur renvoyé par le crate num_cpus.

Vous noterez que la seule ligne qui compose cette fonction ne termine pas par un « ; ». C'est parce que c'est sa dernière expression, qui indique la valeur de retour. Si la dernière expression d'une fonction finit par « ; », sa valeur de retour est () précise la documentation (à moins d'utiliser le mot-clé return).

Ainsi, la version suivante serait également considérée comme correcte :

fn get_cpu_count()-> (usize, usize)
{
return (num_cpus::get(), num_cpus::get_physical());
}

Dans la fonction main(), on ajoute les deux lignes suivantes pour utiliser la fonction :

let (cpu_log, cpu_phy)= get_cpu_count();
println!("CPU Cores : {}, CPU Threads : {}", cpu_phy, cpu_log);

La première consiste à déstructurer le tuple de retour de la fonction get_gpu_count() pour attribuer ses deux valeurs à cpu_log et cpu_phy... en une seule ligne. On utilise ensuite ces valeurs dans un même message. 

Modules et découpage en plusieurs fichiers

Imaginons maintenant que nous voulions organiser notre code sous la forme de différents fichiers réutilisables. Vous utiliserez pour cela des modules. Créez un fichier cpu.rs et déplacez-y get_cpu_count(). On ajoute le mot clé pub devant sa déclaration pour indiquer qu'elle est publique et peut donc être accédée depuis l'extérieur.

Dans main.rs, get_cpu_count() devient cpu::get_cpu_count(), le nom dépendant de celui donné au fichier contenant le module. Pour le référencer on ajoute cette ligne en tête de fichier :

mod cpu;

Si vous recompilez votre code, il fonctionnera comme avant. Mais désormais, vous pouvez utiliser cpu.rs dans d'autres projets. Vous pouvez regrouper plusieurs modules ensemble (dans un même fichier ou plusieurs) et déclarer leurs propres dépendances. C'est la définition de ce qui compose un crate.

Vous trouverez le code final de notre projet et ses différentes étapes d'évolution sur GitHub. Dans notre prochain article, nous reviendrons plus en détail sur les spécificités et la syntaxe de Rust.

Rust Hello
Le résultat final de notre code du jour

Commentaires (50)


Je regarde des tutoriels sur Rust hier soir, et ce matin je vois cet article … Hum … Je me pose des questions sur l’utilisation des cookies du coup ! :windu:
Quelle réactivité ! Bravo ! :mdr:



En tout cas merci pour l’article ! Très intéressant et clair !


:D


Est-ce que qqun sait pk ce langage s’appelle comme ça? C’est un choix plutôt étonnant


De mémoire il n’y a pas de réponse officielle à la question. On voit des théories ici ou là, mais la plus courante est mentionnée dans cette discussion Reddit.


David_L

De mémoire il n’y a pas de réponse officielle à la question. On voit des théories ici ou là, mais la plus courante est mentionnée dans cette discussion Reddit.


Merci pour ta réponse David. J’en ressors pas avec une réponse claire (il n’y en a pas tjs) mais ça m’a qd même ouvert les chakras, du coup j’aime bien :chinois:


J’avais lu je ne sais où que Rust s’appelait Rust (rouille en français donc) parce que la rouille est ce qu’il y a de plus proche physiquement du metal (bare metal, langage bas niveau toussa toussa) mais je trouve plus ma source et apparemment l’inventeur du nom s’amuse à donner une explication différente à chaque fois qu’on le lui demande.


Ah, j’ai bien cru à une jolie blague, puis je me suis rendu compte que j’ai eu droit un sous-titre personnalisé encore plus cool que le vrai, vu que je suis tombé dessus à l’instant: “Il y a une heure - Quelques minutes suffisent”. Ils sont forts chez Next :yes:



Allez, je vais me plonger dans l’article David, mais merci pour le warning : j’attend d’avoir plus de temps :D


Très bonne idée ce tutorial Rust. En revanche, je conseille fortement à ceux qui veulent s’y mettre de lire le Rust book quand ils se lancent sérieusement, parce que le langage a des concepts (lifetimes, Traits) qui peuvent dérouter et sans explications, c’est ardu :)


D’où les nombreux liens vers ce dernier dans l’article ;) Mais on en reparlera plus en détail dans le second article de la série :chinois:


Trop mangé, mais elle était bonne cette raclette :)
J’ai raté un truc ?



Lorsque l’on parle d’apprendre à développer, il est souvent question du trio à tout faire HTML/CSS/JS, pensé pour le web. Parfois de langages plus classiques comme C#, Java, Python ou Ruby. Plus rarement de langages bas niveau tels que C(++), Go ou Rust. Penchons-nous sur ce dernier.




Go, C++ et Rust des langages bas niveau ? À la rigueur je veux bien qu’on le dise pour le C, mais les 3 autres ne sont absolument pas des langages bas niveau.


Rust a un mode nostd, avec la bibliothèque “core” uniquement, qui n’utilise pas d’allocation dynamique et qui peut tourner sur des micro-contrôleurs.


J’ai pensé la même chose, je vois plutôt la notion de langage compilé versus bytecode/interprété entre ces groupes, mais pas bas/haut niveau qui est plus une affaire d’abstraction dans le langage lui-même et non dans son runtime.


Sur ce sujet, j’aime bien le consensus trouvé par le wiki FR :D :




Les discussions stériles pour savoir si des langages comme C et C++, qui ont à la fois des aspects de bas niveau (possibilités d’accès à la mémoire en utilisant des adresses explicites, “bitfields” dans les structures) et de haut niveau, méritent ou pas le nom de langage de haut ou bas niveau ont toujours cours.




Après c’est comme de considérer s’il y a ou non runtime dans ces langages. Oui il y en a une d’une certaine manière, mais on est loin de Java/C#/Node


Moi qui commençais à m’intéresser à ce langage, ça tombe pile. :D
Hâte d’être à ce soir pour pouvoir lire l’article et démarrer tranquillement. :yes:



Merci ! :chinois:


Peut-être utile de dire que la dernière version de Visual Studio Code est disponible sur Raspberry Pi https://code.visualstudio.com/updates/v1_50#_linux-arm-builds



Et que l’extensions “rust-analyser” est plus avancée que l’officielle “Rust” (rust-analyzer est aussi officiel, simplement une nouvelle génération encore en dev)


Sur ARM plus exactement, et donc sur RPi (mais bon il faut l’utiliser en bureau :D). Mais oui, c’est prévu qu’on en parle rapidement (‘ai monté une machine pour tester je dois encore faire quelques tests avant de publier) :chinois:


David_L

Sur ARM plus exactement, et donc sur RPi (mais bon il faut l’utiliser en bureau :D). Mais oui, c’est prévu qu’on en parle rapidement (‘ai monté une machine pour tester je dois encore faire quelques tests avant de publier) :chinois:


Bon, il n’y a pas de build ARM pour rust-analyzer. Dommage. Mais de mémoire l’ext. Rust est fonctionnelle.


Ah cool y’a enfin un .tar.gz. Quand j’ai voulu l’installer sur mon Pinebook Pro (avec Manjaro), le site ne proposait que des rpm et deb donc j’ai du composer avec…


SebGF

Ah cool y’a enfin un .tar.gz. Quand j’ai voulu l’installer sur mon Pinebook Pro (avec Manjaro), le site ne proposait que des rpm et deb donc j’ai du composer avec…


Je n’ai que testé avec Raspbian, mais c’est vrai que je voulais passer en arm64 avec Manjaro. Merci du rappel ;-)


Waw! Bravo et j’admire le courage de lancer une série sur Rust, ce n’est pas le choix de la facilité! :-)



C’est pas le premier langage auquel on pense pour apprendre … D’un autre côté, ne pas avoir l’habitude d’un autre langage, habitudes qui peuvent s’avérer contre-productives en rust, peut-être que c’est un atout.


Disons que, comme dit en intro, ça permet de montrer que le bas niveau n’est pas aussi inabordable que certains le pensent, tout en évitant d’effrayer tout le monde en commençant par du C qui a l’avantage d’être léger, efficace et portable partout… mais vite compliqué à gérer pour faire des choses simples.



Et même si C++ s’est amélioré (notamment avec les smart pointers & co), il paie encore pas mal sa legacy. Du coup, Rust est une sorte de solution assez équilibrée, avec des choix de design qui tranchent et qui permettent d’évoquer des notions qu’on aurait pas en Go par exemple (ne serait-ce que parce qu’il y a un garbage collector).



Pour la petite histoire, à une RMLL je discutais avec quelqu’un qui faisait des cours pour gamins sur du ARM en ASM. Et comme ils commençait par ça, ils n’avaient pas trop de mal à gérer le truc et développaient rapidement de manière assez naturelle.



Après c’est sur que si tu commences par du JS, ça va vite à produire des trucs parfois assez complexes (va faire un web server en ASM ARM :transpi:), mais tu t’habitues à certaines facilités dont il faudra te défaire par la suite.



deathscythe0666 a dit:


Go, C++ et Rust des langages bas niveau ? À la rigueur je veux bien qu’on le dise pour le C, mais les 3 autres ne sont absolument pas des langages bas niveau.




Difficile de définir à quel moment un langage bascule dans le “haut niveau”



Rust est parfaitement utilisable en bas niveau (de ce que j’ai lu, j’espère tester pendant mes vacances :) ). Dans plein de situations, quand on voit le code on imagine ce qui va se faire en assembleur derrière. On peut aussi définir des structures très précises niveau taille et organisation des données. On a bien la main sur heap et stack.



Peu d’abstraction donc, ce qui n’est pas le cas de par exemple de Javascript, C# en programmation “async” (où les instructions, ça va, mais l’organisation du ode et son chemin d’exécution … wow!)



C++ ça va encore, tout dépend où on met le curseur des fonctionnalités. Plus on en utilise, plus il y a de couches entre notre code et le CPU. Java, hormis l’interpréteur nécessaire (sauf en cas de processeur compatible java bytecode?) a des composantes d’interfaçage bas niveau - et un programme simple en Java est facile à imaginer en bytecode - d’ailleurs Java avait par exemple un truc intéressant: le bytecode d’un fonction contient la taille de sa stack, permettant de faire des préventions d’erreur de dépassement de pile.



Par ailleurs, plusieurs projets de recompilation de pilotes, de noyaux en rust existent.



David_L a dit:


Sur ce sujet, j’aime bien le consensus trouvé par le wiki FR :D :



Après c’est comme de considérer s’il y a ou non runtime dans ces langages. Oui il y en a une d’une certaine manière, mais on est loin de Java/C#/Node




À ce compte là, Java via JNI est aussi un langage bas niveau.



Les abstractions en C++ peuvent être très importantes, tout comme on peu se rapprocher de la gestion matérielle (mais là, on est plutôt dans de l’encapsulation C par du C++ que dans un usage standard du langage).


Oui, comme certains considèrent ASM comme le seul vrai bas niveau. Il y a un curseur à placer et comme souvent dans ce genre de cas, beaucoup se focalisent sur le déplacement dudit curseur, quitte à y passer des heures. D’où la citation.



PS : d’ailleurs si on pouvait éviter de pourrir les commentaires avec ces considérations où chacun irait de son avis tout personnel clamé en boucle comme une vérité pure, ce serait pas plus mal :chinois:



deathscythe0666 a dit:


(mais là, on est plutôt dans de l’encapsulation C par du C++ que dans un usage standard du langage).




Du coup, qu’est ce qui te fait dire que rust ne serait pas “bas niveau”?



En tout cas, il est “compatible bas niveau”, ce qui n’est pas le cas de Javascript (en tant que langage, si un moteur particulier l’est, ce n’est pas la même chose)



David_L a dit:


Les discussions stériles pour savoir si des langages comme C et C++, etc.




Ah oui sur le côté stérile en tout cas, rien à redire! 😁


\o/
Un article sur Rust. J’avais pris un peut de temps de pendant le confinement pour essayer ce langage mais j’ai vite eu mal à la tête. :keskidit:



Bref, merci pour cette suite d’articles ! :merci:


Ah, j’ai eu du mal à remettre la main dessus, mais un bon complément à l’article: “A half-hour to learn Rust”: https://fasterthanli.me/articles/a-half-hour-to-learn-rust


Oh purée, en lisant ton article j’ai enfin compris pourquoi “if let”. J’ai toujours pensé que c’était juste un raccourci pour un “match simplifié”, du coup je trouvais le nommage complètement débile.



Mais en fait c’est juste pas du tout ça mais juste le retour de l’expression de la destructuration (let Machin(y) = x) qui est passé au if. Mind blowing


jpaul

Oh purée, en lisant ton article j’ai enfin compris pourquoi “if let”. J’ai toujours pensé que c’était juste un raccourci pour un “match simplifié”, du coup je trouvais le nommage complètement débile.



Mais en fait c’est juste pas du tout ça mais juste le retour de l’expression de la destructuration (let Machin(y) = x) qui est passé au if. Mind blowing


Ouais, j’aurais bien voulu trouver cette page avant de me taper tout le bouquin ^_^


A quand un tuto kotlin :D


Faut faire un tuto Gradle/Maven d’abord, parce qu’après avoir utilisé cargo, ça va piquer :-D


Très bonne idée d’expliquer comment installer de quoi développer avec Rust, c’est parfois pas évident.
Néanmoins, je serais plus prudent sur l’apprentissage du code. D’expérience, Rust demande de passer pas mal de temps à comprendre ses principes, il est très difficile d’apprendre au fil de l’eau comme avec du C, Java ou C#. Je vois plein de gens essayer Rust en bidouillant, et tous abandonnent car il faut vraiment avoir compris la philosophie Rust (gestion des espaces mémoire par ex) pour ne pas perdre la tête. Ceux que je vois réussir et persévérer dans Rust (sur de vrais projets), ce sont ceux et celles qui potassent d’abord la doc. C’est moins sexy, mais Rust n’est clairement pas autant accessible que d’autres langages.


D’où la seconde partie qui arrive ;)


Bon, semblerai que rust-analyzer (ext. VS Code) soit dispo pour Raspberry Pi avec Manjaro (arm64). Il faut faire l’installation avec pacman et configurer le path, mais ça fonctionne, ce qui est une bonne nouvelle :top:


Pour info, certains apprennent toujours Pascal pour apprendre les bases de la programmation.


Je ne sais pas quelle est la norme aujourd’hui dans les universités, mais je pense que Go pourrait être intéressant en remplaçant : accessible pour débutants, typé, utilisé dans l’industrie. Pas comme seul et unique langage à apprendre, mais aux côtés d’autre(s), qui offriraient des paradigmes différents, genre Python.


jotak

Je ne sais pas quelle est la norme aujourd’hui dans les universités, mais je pense que Go pourrait être intéressant en remplaçant : accessible pour débutants, typé, utilisé dans l’industrie. Pas comme seul et unique langage à apprendre, mais aux côtés d’autre(s), qui offriraient des paradigmes différents, genre Python.


Le souci de Go en apprentissage, c’est que tu restes sur des mécaniques de type GC & co. Du coup le trio Rust/Python/C# me parait pas mal pour un tryptique avec du compilé/script avec ou sans GC, etc. Après on peut remplacer par Go/Ruby/Java hein, mais Rust me semble justement intéressant parce qu’il prend des positions inhabituelles intéressantes à prendre en compte.


David_L

Le souci de Go en apprentissage, c’est que tu restes sur des mécaniques de type GC & co. Du coup le trio Rust/Python/C# me parait pas mal pour un tryptique avec du compilé/script avec ou sans GC, etc. Après on peut remplacer par Go/Ruby/Java hein, mais Rust me semble justement intéressant parce qu’il prend des positions inhabituelles intéressantes à prendre en compte.


Je trouve Rust très intéressant aussi mais je ne le verrais pas enseigné en premier langage parce qu’à mon avis trop susceptible de dégoûter un paquet de monde, la courbe d’apprentissage étant ardue, je pense que ça peut convenir à des écoles un peu élitistes mais pas à un système plus généraliste. Par exemple, ici sur NextInpact ça intéresse du monde car l’audience est curieuse / geek / motivée, mais aller appliquer ça sur une audience plus large et hétéroclite … j’ai des doutes.
Après, c’est certainement un des langages les plus intéressants pour l’université mais à un niveau plus élevé genre Master. Enfin c’est juste mon avis :-)



Quant au GC je ne vois pas ça comme un frein, on peut avoir des fuites de mémoire avec ou sans GC, donc dans tous les cas il faut comprendre un peu ce qu’il se passe sous le capot. C’est d’ailleurs sans doute intéressant d’en expérimenter soi-même pour justement voir l’intérêt de le gestion de la mémoire à la rust. Ça fait même un bon enchaînement je trouve : en Licence les étudiants apprennent Go, en Master ils en voient les limites et passent à Rust :-)


jotak

Je trouve Rust très intéressant aussi mais je ne le verrais pas enseigné en premier langage parce qu’à mon avis trop susceptible de dégoûter un paquet de monde, la courbe d’apprentissage étant ardue, je pense que ça peut convenir à des écoles un peu élitistes mais pas à un système plus généraliste. Par exemple, ici sur NextInpact ça intéresse du monde car l’audience est curieuse / geek / motivée, mais aller appliquer ça sur une audience plus large et hétéroclite … j’ai des doutes.
Après, c’est certainement un des langages les plus intéressants pour l’université mais à un niveau plus élevé genre Master. Enfin c’est juste mon avis :-)



Quant au GC je ne vois pas ça comme un frein, on peut avoir des fuites de mémoire avec ou sans GC, donc dans tous les cas il faut comprendre un peu ce qu’il se passe sous le capot. C’est d’ailleurs sans doute intéressant d’en expérimenter soi-même pour justement voir l’intérêt de le gestion de la mémoire à la rust. Ça fait même un bon enchaînement je trouve : en Licence les étudiants apprennent Go, en Master ils en voient les limites et passent à Rust :-)


Ah oui, autant commencer par du Python pour faire rapidement des trucs cools et un minimum cadré sans partir dans des blobs de 100 Mo à la Node/Electron :D L’intérêt est de toutes façons dans le fait de voir/comprendre différents types de langages. C’est l’intérêt de Rust en complément avec un autre qui se base sur un GC. Tu peux voir les avantages d’une gestion automatisée, ou une qui ne l’est pas mais reste “memory safe”.


L’installation (sous Ubuntu 18.04) s’est bien passée, mais bizarrement les variables $PATH n’ont pas été mises à jour. Je dois lancer la commande depuis /home/moi/.cargo/bin.
(on va me répondre de passer à 20.04, mais je doute que ce soit ça :D)



xapon a dit:


Pour info, certains apprennent toujours Pascal pour apprendre les bases de la programmation.




C’est normal, c’est le langage le plus utilisé dans l’industrie :D



jotak a dit:


Je trouve Rust très intéressant aussi mais je ne le verrais pas enseigné en premier langage parce qu’à mon avis trop susceptible de dégoûter un paquet de monde, la courbe d’apprentissage étant ardue, je pense que ça peut convenir à des écoles un peu élitistes mais pas à un système plus généraliste.




Fait intéressant, je trouve au contraire que tout ce qui est difficile dans l’apprentissage de Rust c’est de devoir mettre de côté toutes mes habitudes de développements sur des langages à GC. Et je ne parle même pas des mauvaises habitudes, mais bien de patterns de programmation tout à fait respectables qui ne sont en fait implémentables que dans des langages orientés objet avec héritage de classe et avec garbage collector.



Ce qui me pousse à continuer à apprendre Rust, c’est que malgré le fait que j’en chie à faire compiler le code que je pond, le langage en lui même (en relecture par exemple) est vraiment “simple”.



Ce qui est difficile c’est justement que le compilateur te force à réfléchir à des trucs (gestion de la mémoire, pointeurs, heap/stack) que tu avais vu et totalement compris en cours mais que tu oublies largement quand tu fais du C# ou du JS au quotidien.



Ma conclusion, même si on peut en débattre, c’est que Rust est au contraire un excellent langage à apprendre au plus tôt, quand tu n’as pas encore pris des tonnes d’habitudes professionnelles et que les notions qu’il demande de connaître sont fraîches du cours précédent.



Je le voit même comme un excellent remplaçant académique à C++ qui contrairement à C++ est un langage intéressant à avoir dans une boite à outil de dev professionnel (parce que bon, dans le monde pro, ça devient un peu déraisonnable de démarrer un nouveau projet en C++ en 2020 à moins d’y être forcé)


Tout dépend, si tu le démarre en C++20, ça passe :transpi:


David_L

Tout dépend, si tu le démarre en C++20, ça passe :transpi:


Pour être honnête j’ai plus touché à C++ depuis mes cours. Ça va bientôt faire une décennie. Donc je suis bien incapable de te dire dans quel état est l’écosystème C++ aujourd’hui. Donc je balance peut être des idées reçues (j’espère pas, et j’espère qu’on me reprendra si c’est le cas).



J’ai aussi une pointe de rancœur contre ce langage parce qu’il me semble être celui qui a lancé la mode toujours aussi présente aujourd’hui des “symboles partout dans le code”. Symbole au sens scriptural du terme, ceux qui rendent le code fatigant à lire pour des humains du genre if(!machin && bidule) au lieu de if bidule and not machin. D’ailleurs je suis déçu que Rust ne soit pas plus verbeux (au sens purement de la syntaxe). Pourtant Python devrait être une inspiration en terme de compromis verbosité/clarté.


jpaul

Pour être honnête j’ai plus touché à C++ depuis mes cours. Ça va bientôt faire une décennie. Donc je suis bien incapable de te dire dans quel état est l’écosystème C++ aujourd’hui. Donc je balance peut être des idées reçues (j’espère pas, et j’espère qu’on me reprendra si c’est le cas).



J’ai aussi une pointe de rancœur contre ce langage parce qu’il me semble être celui qui a lancé la mode toujours aussi présente aujourd’hui des “symboles partout dans le code”. Symbole au sens scriptural du terme, ceux qui rendent le code fatigant à lire pour des humains du genre if(!machin && bidule) au lieu de if bidule and not machin. D’ailleurs je suis déçu que Rust ne soit pas plus verbeux (au sens purement de la syntaxe). Pourtant Python devrait être une inspiration en terme de compromis verbosité/clarté.


Pourtant



if (bidule and not machin)


c’est du c++ standard :D


wagaf

Pourtant



if (bidule and not machin)


c’est du c++ standard :D


Je l’apprends :chinois:


J’allais dire la même chose. Une fois qu’on a viré toutes les habitudes, Rust est un langage très facile je trouve. J’ai écris plusieurs programmes déjà et pas une seule lifetime sur plusieurs milliers de ligne. (ou alors juste pour les &str au lieu de String dans les struct, mais on peut très bien s’en passer)



Il faut faire attention aussi. Il y a pas mal de librairies qui ne sont pas très “rusty” justement et qui te prenne le choux pour aucune raison valable autre que “je fais comme le framework X”. Mais comme Rust ne ressemble à rien d’autre, ben ça foire.



J’aime beaucoup Kotlin aussi, je le trouve agréable, comme Rust, pour le moment (bon ça fait 3 jours que je joue avec)



jpaul a dit:


D’ailleurs je suis déçu que Rust ne soit pas plus verbeux (au sens purement de la syntaxe). Pourtant Python devrait être une inspiration en terme de compromis verbosité/clarté.




C’est un aspect qu j’aime bien dans Python d’ailleurs. Je précise, je ne suis développeur ni de formation ni de profession, mais vu que je bosse principalement dans l’indus, l’automatisation et le déploiement, je suis amené à écrire des scripts ou petits utilitaires.



J’ai récemment trouvé une idée de truc à faire en Python pour m’initier à ce langage (principalement vu au travers d’Ansible) et je le trouve assez intuitif pour quelqu’un comme moi. De plus, comme le respect de l’indentation est obligatoire, ça rend le code plus lisible en complément de ces déclarations textuelles.


Fermer