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
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).
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 |
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 !
Laisser un commentaire