Qu'est-ce que c'est ? Un Avion ? Une Fusée ? Ha, non, juste de la rouille …
Rust est la traduction du mot "rouille" en anglais, ainsi qu'un jeu vidéo de survie post-apocalyptique, mais c'est aussi un langage de programmation. Et vous devez maintenant vous demander :
Encore un autre langage, mais pourquoi ?
Les origines
En 2006 Graydon Hoare, un développeur chez Mozilla, commence un projet personnel, un nouveau langage de programmation qu'il va nommer Rust. Trois ans plus tard, le langage est jugé suffisamment mature pour intéresser Mozilla, qui décide de le prendre sous son aile. Confrontés aux problèmes de sécurité du C++, notamment au niveau de la gestion de la mémoire, les ingénieurs en charge du développement souhaitaient utiliser un langage de programmation à la fois sécurisé, aux performances comparables au C++, et capable d'intégrer la gestion de la concurrence. Ils décidèrent donc d'utiliser Rust, langage basé sur 3 points essentiels : rapidité, concurrence et sécurité. Le projet Servo, un nouveau moteur de rendu HTML écrit en Rust, a été lancé avec succès en 2010 par Mozilla. Certains modules de Servo commencent à être intégrés dans Firefox, donc oui, si vous utilisez ce navigateur web, vous utilisez déjà Rust !
En résumé, chez Mozilla, pour créer un nouveau moteur de rendu HTML, on développe un nouveau langage. Ben oui, parce que sinon, y'a pas de challenge !
Il est différent !
Compilé mais pas con
Rust est un langage compilé. Les langages appartenant à cette famille sont les plus rapides, car généralement de plus bas niveau, ce qui permet une gestion plus fine, et donc meilleure, de la mémoire. Cependant, un grand pouvoir implique de grandes responsabilités ! Et c'est bien connu, les super-héros font souvent n'importe quoi avec leurs pouvoirs. Et cela attire les super méchants, qui sont (entre autres) la fuite mémoire, la bad alloc, et la fameuse et redoutable segmentation fault. Heureusement, un certain nombre d'outils existe pour se prémunir de ces terribles ennemis. Nous pourrons citer, pêle-mêle : les garbage collectors, l'analyse statique du code source, les débuggeurs, ou encore l'analyse dynamique à l’exécution. Tous ces outils sont efficaces, mais présentent un certain nombre de contraintes :
- Perte de performance
- Consommation mémoire plus importante
- Et, plus grave, perte de temps pour le développeur
Pourquoi attendre alors qu'on pourrait boire un café ?
Mais le plus embêtant est qu'ils interviennent tardivement dans le développement du logiciel, ce qui peut engendrer de la lenteur au niveau de la production, en créant des allers-retours entre l'écriture et le débuggage. Rust a une approche différente. Via une analyse du code à la compilation, il signale immédiatement les problèmes dans la gestion de la mémoire. Ceci, allié à sa syntaxe rigide et son typage fort, garantit que si votre programme passe la compilation, il ne présentera pas de fuite mémoire. Il peut y avoir d'autres bugs, bien sûr, mais pour la gestion de la mémoire il n'y aura pas de souci à se faire (enfin, si vous avez confiance en Rust, et en vos dépendances).
Un programme lambda.
Cargo, l'Alfred de Rust
Comment expliquer à quoi sert Cargo ? À tout : c'est un gestionnaire de compilation, de dépendances, de test, de benchmark et également un générateur de documentation. Un autre énorme avantage de Cargo est qu'il est intégré directement au langage, il n'y a donc pas besoin d'un autre outil. Il aide enfin à créer votre nouveau projet, en créant directement l'architecture de votre programme ou de vos bibliothèques logicielles (les crates). Il gère d'ailleurs l'installation, le chargement et la mise à jour de ces dernières. Une rumeur prétend qu'il est également capable de faire le café.
Cet outil permet au final une gestion très souple des dépendances et donc des déploiements grandement facilités. Et ceci fera très plaisir à l'administrateur système de votre cluster de calcul, une fois qu'il aura accepté d'installer Rust, bien sûr.
Et des gadgets trop fun
Les points précédents sont les plus importants à noter, mais il y a plus :
- POO par prototype
- Une syntaxe de macros élégante
- Tout est immutable par défaut
- Un contrôle fort de la propriété des variables
- Une gestion de la programmation concurrente
Concrètement, quels sont les intérêts ?
Plus rapide que Flash
Enfin aussi rapide que le C++, dans le cas où le programme en C++ procède aux vérifications de sécurité intégrées dans Rust. Étant donné l'accroissement important de la quantité de données à analyser en bioinformatique, les outils à concevoir dans le futur vont devoir être de plus en plus performants et optimisés. Rust étant un langage compilé et intégrant dans sa conception la programmation concurrente, cela fait de lui un bon candidat pour la création de futurs outils.
Là où Rust devient vraiment intéressant, c'est avec sa philosophie axée sur la sécurité. Là où en C++, il peut s'avérer nécessaire d'avoir un véritable expert du langage, pour vérifier les fuites mémoires, mauvaises allocations, et autres problèmes éventuels, en Rust ces vérifications sont intégrées au langage. Ainsi, le temps de développement sera fortement raccourci. Loin de moi l'idée de dénigrer les autres langages, j'aime beaucoup C++ par exemple, mais je ne me sens pas suffisamment à l'aise pour coder un gros outil avec. Là où j'aurais bien moins d'appréhension avec Rust, justement parce qu'il vérifie toute la sécurité pour moi.
Aussi intelligent qu'Enigma
C'est un fait, nous ne savons pas programmer parfaitement. Nous faisons tous des erreurs, même les plus grands développeurs le disent, personne n'est à l’abri d'un bug.
Il existe un ensemble d'outils pour éviter ces erreurs, mais l'un des gros avantages de Rust, c'est que tous ces outils sont déjà intégrés dans le langage. Rust ne vous empêchera pas de faire des erreurs dans le code, mais son compilateur les détectera et, surtout, vous expliquera comment les corriger. Fini les segmentation faults d'origine inconnue !
Le typage fort permet d'éviter l'erreur classique qui consiste à additionner des choux et des carottes. Cela permet également au compilateur un certain nombre d'optimisations. Cette propriété peut parfois être pénible, mais elle est importante.
Par défaut en Rust tout est immutable, on ne peut rien changer.
|
1 2 3 4 |
let x = 1; x = 2; // le compilateur lève une erreur let mut x = 1; // Ici, x est défini comme mutable, on peut donc le modifier ultérieurement x = 2; |
Autre chose très utile dans Rust, les variables appartiennent à un seul et unique bloc (un bloc est, grossièrement, l'espace entre { }).
|
1 2 3 4 5 6 7 |
fn function_x(val: u32) { // Rien faire, et souvent, c'est cool } let x = 1; function_x(x); println!("{}", x) // Le compilateur lèvera une erreur car la variable x ne contient plus rien: // sa valeur a été donnée a la fonction function\_x qui a désalloué cette valeur a la fin du bloc |
Ça peut paraître très pénible, mais ça aide le compilateur à vérifier la mémoire, et cela évite les effets de bord. La fonction function_x a potentiellement modifié la valeur de x, et si la valeur n'est pas retournée, on n'est pas sûr que la valeur contenue dans x soit toujours la bonne. Il vaut donc mieux ne pas y accéder. Pour pouvoir passer des variables à des fonctions en Rust et réutiliser ces variables plus tard, il faut soit retourner la valeur, soit effectuer un passage par référence.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
fn function_x_return(val: u32) -> u32{ // Rien faire souvent c'est cool val; // le mot clef <em>return</em> est implicite en Rust } fn function_x_reference(val: &u32) { // Rien faire souvent c'est cool } let x1 = 2; let x2 = 1; x1 = function_x_return(x1); // Le bloc perd la propriété de la valeur de x1 mais la réobtient a la fin de la fonction function_x_reference(&x2); // On transmet la référence (position en mémoire) de la variable x2 on ne perd pas sa propriété println!("{}", x1) // Pas de problème println!("{}", x2) // Pas de problème |
La banane c'est la variable, je vous laisse deviner qui sont les fonctions…
Le passage par référence est quelque chose de connu dans d'autres langages. Dans le cas de Rust, en plus d'éviter une copie en mémoire, il participe à la vérification du programme. Le fait qu'il soit explicite permet de ne pas l'oublier.
Aussi souple que Mister Fantastique
Grâce à Cargo, développer, tester, documenter, déployer ou publier un programme n'a jamais été aussi simple. Finis le drame des dépendances pas à jour ou celui des architectures non supportées ! Vous allez gagner du temps et donc pouvoir vous atteler à votre prochaine tâche (aller boire un bon café, par exemple).
Comme dit plus haut, le langage Rust est très strict. Cependant, vous avez toujours la possibilité de demander à Rust d'être plus conciliant, grâce au mot-clé unsafe. Ce n'est pas recommandé, mais au moins, la zone codée de cette manière est bien balisée.
Rust needs YOU
Rust c'est un super-héros trop cool, du coup il a créé son propre robot pour l'aider dans ses analyses des données biologiques. Il lui a même donné un nom super original : Rust-Bio.
Ce que Rust-Bio sait faire
Pour l'instant Rust-Bio sait faire quelques trucs :
- Lire et écrire des fichiers fasta, fastq, gff et bed
- Aligner des séquences
- Générer et utiliser une BWT et un FM-Index
Et quelques autres trucs, dont vous pouvez avoir un aperçu dans ce README.
Ce qu'il lui reste à apprendre
Beaucoup. Mais la communauté Rust est très accueillante et le projet Rust-Bio aussi. Même si vous ne connaissez rien au langage, vous pourrez assez facilement participer. Je vous recommande de regarder du côté de ce ticket qui liste les tâches à effectuer.
En conclusion
Cet article n'a évidemment pas présenté Rust dans son intégralité, on peut dire que c'est un teasing du langage. Allez découvrir ce langage, ainsi que ses limites (oui, elles existent). Rust n'est pas la panacée, il y a encore de nombreux cas où Rust ne sera pas intéressant :
- des pipelines (je n'ai pas trouvé de framework)
- des statistiques (pour l'instant, ça a l'air compliqué)
- le prototypage (c'est plus facile en Python)
On continuera bien sûr à utiliser d'autres langages, ce qui est une bonne chose, mais je pense que Rust a le (super) pouvoir de remplacer Java et C++ comme langage pour le calcul intensif dans le futur. Et faire gagner beaucoup de temps a beaucoup de monde.
(Re)?sources intéressantes
Le site du projet : https://www.rust-lang.org/
L'article Léa Linux : http://lea-linux.org/documentations/Rust
L'article Wikipédia
Apprendre le Rust : http://doc.rust-lang.org/book/
Le projet Rust-bio : https://github.com/rust-bio/rust-bio
Conférence sur Servo : https://www.youtube.com/watch?v=7q9vIMXSTzc
OS en Rust : http://www.redox-os.org/
Le chan IRC francophone Rust-fr : irc://irc.mozilla.org/rust-fr
Awesome Rust : https://github.com/kud1ing/awesome-rust
________________________________________________________________________________________________
Un grand merci aux relecteurs, Bunny, Bebabut, Maxi_Zu et lroy pour les corrections d'un article qui fut long à finaliser !
nibua
novembre 9, 2016 à 9:45
Petite question innocente: quelle différence importantes trouvez vous entre Go et Rust? Go est également proche de C/C+ et intègre de façon transparente le parallélisme?
Rust a même l'air plus "compliqué" dans l'écriture. J'y vois du pour (ça amènerait le programmeur a produire du code moins buggé) et du contre (temps et complexité d'écriture, investissement plus conséquent en formation).
Pierre Marijon
novembre 9, 2016 à 10:35
C'est une question très délicate, les deux langages on été rendu publique à peu près au même moment avec a peu près les mêmes objectifs (grossièrement remplacer le Java et le C++) et par deux concurrents. On va rapidement casser le suspense je suis partisan, je me suis plus intéressé à Rust car je suis plus proche des idées défendues par Mozzila, donc je connais mieux Rust que Go.
Mais j'ai quand même un peu testé le Go. C'était dans le cadre d'un gros projet donc il y avait déjà de la complexité, ce qui peut biaisé mon jugement, mais j'ai le sentiment que les complexités sont équivalentes.
Ensuite quelques inconvénients qu'a le Go par rapport au Rust en mon sens :
- Le gabrage collector, qui va forcement augmenter la taille de votre programme, son temps d’exécution et sa consommation de mémoire. Mais en contre partie on *peut* gagner du temps de développement. Et surtout ça empêche au développeur d'avoir une gestion fine de sa mémoire, même si cette possibilité amène souvent des bugs, Rust les résoud de manière plus élégante.
- La gestion des dépendances. Cargo va créé tout seul comme un grand un .cargo dans votre $HOME et y ranger vos dépendances. En Go il faut créé une variable d’environnement pour que Go sache où aller chercher/installer ces dépendances, je trouve que c'est un peu plus lourd l’environnement de développement et plus long à mettre en place.
- Le Go n'est pas UNIX, Rust l'est plus. La commande go fait tout formatage du code/compilation/gestion des dépendances. rustc n'est que le compilateur, cargo ne fait que la gestion de projet, j'apprécie ce découplage.
En vérifiant mes arguments pour cette réponse j'ai lu https://en.wikipedia.org/wiki/Go_(programming_language)#Omissions et effectivement il y a un certain nombre d'omissions qui me semble injustifié, notamment la programmation générique.
Voilà j'espère avoir été clair et que tu as bien compris que Rust est meilleur que le Go d'abord.
Breizh
novembre 10, 2016 à 3:30
Et un autre point important, le Rust a plus de paradigmes. Du fonctionnel à l'objet en passant par l'impératif et sans oublier le concurrent… certes, il y a beaucoup de paradigmes existants, mais ceux-là ont tous de gros avantages, et pouvoir les combiner est tellement pratique…
Pierre Marijon
novembre 10, 2016 à 3:59
Pour le coup j'ai envie de dire que c'est un avantage et un inconvénient pour l'adoption du langage :
Un avantage car effectivement plus de fonctionnalité, plus de bonheur, on peut faire plus de chose avec le langage, ça va être plus facile de faire certaines choses, etc …
Un inconvénient car ça rend plus difficile l'adoption du langage, le langage va être plus complexe, et on va prendre plus de temps a le maîtrisé, et donc il y aura moins de développeur.
darthyoh
décembre 17, 2017 à 9:03
Salut.
Super article.
Petite erreur détectée dans l'explication du passage par référence (quand tu parles de l'ownership )
// le mot clef return est implicite en Rust
=> oui... mais seulement si tu vires le ";" derrière val pour que ça reste une expression. Avec le point virgule, ça devient un statement et la fonction ne retournera rien du tout ! La, ça ne fonctionne pas.
Bisous
Pierre Marijon
janvier 21, 2018 à 5:44
Merci effectivement tu raison j'applique un correctif le plus rapidement possible.