- Le blog participatif de bioinformatique francophone depuis 2012 -

Rust, un super héros au secours de la bio-informatique ?

 

Rust ne sauve pas de l'ADN
Qu'est-ce que c'est ? Un Avion ? Une Fusée ? Ha, non, juste de la rouille …

Rust est la tra­duc­tion du mot "rouille" en anglais, ain­si qu'un jeu vidéo de sur­vie post-apo­ca­lyp­tique, mais c'est aus­si un lan­gage de pro­gram­ma­tion. Et vous devez main­te­nant vous deman­der :

Encore un autre langage, mais pourquoi ?

Les origines

En 2006 Gray­don Hoare, un déve­lop­peur chez Mozilla, com­mence un pro­jet per­son­nel, un nou­veau lan­gage de pro­gram­ma­tion qu'il va nom­mer Rust. Trois ans plus tard, le lan­gage est jugé suf­fi­sam­ment mature pour inté­res­ser Mozilla, qui décide de le prendre sous son aile. Confron­tés aux pro­blèmes de sécu­ri­té du C++, notam­ment au niveau de la ges­tion de la mémoire, les ingé­nieurs en charge du déve­lop­pe­ment sou­hai­taient uti­li­ser un lan­gage de pro­gram­ma­tion à la fois sécu­ri­sé, aux per­for­mances com­pa­rables au C++, et capable d'intégrer la ges­tion de la concur­rence. Ils déci­dèrent donc d'utiliser Rust, lan­gage basé sur 3 points essen­tiels : rapi­di­té, concur­rence et sécu­ri­té. Le pro­jet Ser­vo, un nou­veau moteur de ren­du HTML écrit en Rust, a été lan­cé avec suc­cès en 2010 par Mozilla. Cer­tains modules de Ser­vo com­mencent à être inté­grés dans Fire­fox, donc oui, si vous uti­li­sez ce navi­ga­teur web, vous uti­li­sez déjà Rust !

En résu­mé, chez Mozilla, pour créer un nou­veau moteur de ren­du HTML, on déve­loppe un nou­veau lan­gage. Ben oui, parce que sinon, y'a pas de chal­lenge !

Il est différent !

Compilé mais pas con

Rust est un lan­gage com­pi­lé. Les lan­gages appar­te­nant à cette famille sont les plus rapides, car géné­ra­le­ment de plus bas niveau, ce qui per­met une ges­tion plus fine, et donc meilleure, de la mémoire. Cepen­dant, un grand pou­voir implique de grandes res­pon­sa­bi­li­tés ! Et c'est bien connu, les super-héros font sou­vent n'importe quoi avec leurs pou­voirs. Et cela attire les super méchants, qui sont (entre autres) la fuite mémoire, la bad alloc, et la fameuse et redou­table seg­men­ta­tion fault. Heu­reu­se­ment, un cer­tain nombre d'outils existe pour se pré­mu­nir de ces ter­ribles enne­mis. Nous pour­rons citer, pêle-mêle : les gar­bage col­lec­tors, l'analyse sta­tique du code source, les débug­geurs, ou encore l'analyse dyna­mique à l’exécution. Tous ces outils sont effi­caces, mais pré­sentent un cer­tain nombre de contraintes :

  • Perte de per­for­mance
  • Consom­ma­tion mémoire plus impor­tante
  • Et, plus grave, perte de temps pour le déve­lop­peur
pourquoi attendre alors qu'on pourraient boire un café.
Pour­quoi attendre alors qu'on pour­rait boire un café ?

Mais le plus embê­tant est qu'ils inter­viennent tar­di­ve­ment dans le déve­lop­pe­ment du logi­ciel, ce qui peut engen­drer de la len­teur au niveau de la pro­duc­tion, en créant des allers-retours entre l'écriture et le débug­gage. Rust a une approche dif­fé­rente. Via une ana­lyse du code à la com­pi­la­tion, il signale immé­dia­te­ment les pro­blèmes dans la ges­tion de la mémoire. Ceci, allié à sa syn­taxe rigide et son typage fort, garan­tit que si votre pro­gramme passe la com­pi­la­tion, il ne pré­sen­te­ra pas de fuite mémoire. Il peut y avoir d'autres bugs, bien sûr, mais pour la ges­tion de la mémoire il n'y aura pas de sou­ci à se faire (enfin, si vous avez confiance en Rust, et en vos dépen­dances).

1dij2x
Un pro­gramme lamb­da.

Cargo, l'Alfred de Rust

Com­ment expli­quer à quoi sert Car­go ? À tout : c'est un ges­tion­naire de com­pi­la­tion, de dépen­dances, de test, de bench­mark et éga­le­ment un géné­ra­teur de docu­men­ta­tion. Un autre énorme avan­tage de Car­go est qu'il est inté­gré direc­te­ment au lan­gage, il n'y a donc pas besoin d'un autre outil. Il aide enfin à créer votre nou­veau pro­jet, en créant direc­te­ment l'architecture de votre pro­gramme ou de vos biblio­thèques logi­cielles (les crates). Il gère d'ailleurs l'installation, le char­ge­ment et la mise à jour de ces der­nières. Une rumeur pré­tend qu'il est éga­le­ment capable de faire le café.

Cet outil per­met au final une ges­tion très souple des dépen­dances et donc des déploie­ments gran­de­ment faci­li­tés. Et ceci fera très plai­sir à l'administrateur sys­tème de votre clus­ter de cal­cul, une fois qu'il aura accep­té d'installer Rust, bien sûr.

Et des gadgets trop fun

Les points pré­cé­dents sont les plus impor­tants à noter, mais il y a plus :

Concrètement, quels sont les intérêts ?

Plus rapide que Flash

Enfin aus­si rapide que le C++, dans le cas où le pro­gramme en C++ pro­cède aux véri­fi­ca­tions de sécu­ri­té inté­grées dans Rust. Étant don­né l'accroissement impor­tant de la quan­ti­té de don­nées à ana­ly­ser en bio­in­for­ma­tique, les outils à conce­voir dans le futur vont devoir être de plus en plus per­for­mants et opti­mi­sés. Rust étant un lan­gage com­pi­lé et inté­grant dans sa concep­tion la pro­gram­ma­tion concur­rente, cela fait de lui un bon can­di­dat pour la créa­tion de futurs outils.
Là où Rust devient vrai­ment inté­res­sant, c'est avec sa phi­lo­so­phie axée sur la sécu­ri­té. Là où en C++, il peut s'avérer néces­saire d'avoir un véri­table expert du lan­gage, pour véri­fier les fuites mémoires, mau­vaises allo­ca­tions, et autres pro­blèmes éven­tuels, en Rust ces véri­fi­ca­tions sont inté­grées au lan­gage. Ain­si, le temps de déve­lop­pe­ment sera for­te­ment rac­cour­ci. Loin de moi l'idée de déni­grer les autres lan­gages, j'aime beau­coup C++ par exemple, mais je ne me sens pas suf­fi­sam­ment à l'aise pour coder un gros outil avec. Là où j'aurais bien moins d'appréhension avec Rust, jus­te­ment parce qu'il véri­fie toute la sécu­ri­té pour moi.

Aussi intelligent qu'Enigma

C'est un fait, nous ne savons pas pro­gram­mer par­fai­te­ment. Nous fai­sons tous des erreurs, même les plus grands déve­lop­peurs le disent, per­sonne n'est à l’abri d'un bug.
Il existe un ensemble d'outils pour évi­ter ces erreurs, mais l'un des gros avan­tages de Rust, c'est que tous ces outils sont déjà inté­grés dans le lan­gage. Rust ne vous empê­che­ra pas de faire des erreurs dans le code, mais son com­pi­la­teur les détec­te­ra et, sur­tout, vous expli­que­ra com­ment les cor­ri­ger. Fini les seg­men­ta­tion faults d'origine incon­nue !
Le typage fort per­met d'éviter l'erreur clas­sique qui consiste à addi­tion­ner des choux et des carottes. Cela per­met éga­le­ment au com­pi­la­teur un cer­tain nombre d'optimisations. Cette pro­prié­té peut par­fois être pénible, mais elle est impor­tante.
Par défaut en Rust tout est immu­table, on ne peut rien chan­ger.

Autre chose très utile dans Rust, les variables appar­tiennent à un seul et unique bloc (un bloc est, gros­siè­re­ment, l'espace entre { }).

Ça peut paraître très pénible, mais ça aide le com­pi­la­teur à véri­fier la mémoire, et cela évite les effets de bord. La fonc­tion function_​x a poten­tiel­le­ment modi­fié la valeur de x, et si la valeur n'est pas retour­née, on n'est pas sûr que la valeur conte­nue dans x soit tou­jours la bonne. Il vaut donc mieux ne pas y accé­der. Pour pou­voir pas­ser des variables à des fonc­tions en Rust et réuti­li­ser ces variables plus tard, il faut soit retour­ner la valeur, soit effec­tuer un pas­sage par réfé­rence.

La banane c'est la variable, je vous laisse deviner qui sont les fonctions …
La banane c'est la variable, je vous laisse devi­ner qui sont les fonc­tions…

Le pas­sage par réfé­rence est quelque chose de connu dans d'autres lan­gages. Dans le cas de Rust, en plus d'éviter une copie en mémoire, il par­ti­cipe à la véri­fi­ca­tion du pro­gramme. Le fait qu'il soit expli­cite per­met de ne pas l'oublier.

Aussi souple que Mister Fantastique

Grâce à Car­go, déve­lop­per, tes­ter, docu­men­ter, déployer ou publier un pro­gramme n'a jamais été aus­si simple. Finis le drame des dépen­dances pas à jour ou celui des archi­tec­tures non sup­por­tées ! Vous allez gagner du temps et donc pou­voir vous atte­ler à votre pro­chaine tâche (aller boire un bon café, par exemple).
Comme dit plus haut, le lan­gage Rust est très strict. Cepen­dant, vous avez tou­jours la pos­si­bi­li­té de deman­der à Rust d'être plus conci­liant, grâce au mot-clé unsafe. Ce n'est pas recom­man­dé, mais au moins, la zone codée de cette manière est bien bali­sé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 ana­lyses des don­nées bio­lo­giques. Il lui a même don­né un nom super ori­gi­nal : Rust-Bio.

Ce que Rust-Bio sait faire

Pour l'instant Rust-Bio sait faire quelques trucs :

  • Lire et écrire des fichiers fas­ta, fastq, gff et bed
  • Ali­gner des séquences
  • Géné­rer et uti­li­ser une BWT et un FM-Index

Et quelques autres trucs, dont vous pou­vez avoir un aper­çu dans ce README.

Ce qu'il lui reste à apprendre

Beau­coup. Mais la com­mu­nau­té Rust est très accueillante et le pro­jet Rust-Bio aus­si. Même si vous ne connais­sez rien au lan­gage, vous pour­rez assez faci­le­ment par­ti­ci­per. Je vous recom­mande de regar­der du côté de ce ticket qui liste les tâches à effec­tuer.

En conclusion

Cet article n'a évi­dem­ment pas pré­sen­té Rust dans son inté­gra­li­té, on peut dire que c'est un tea­sing du lan­gage. Allez décou­vrir ce lan­gage, ain­si que ses limites (oui, elles existent). Rust n'est pas la pana­cée, il y a encore de nom­breux cas où Rust ne sera pas inté­res­sant :

  • des pipe­lines (je n'ai pas trou­vé de fra­me­work)
  • des sta­tis­tiques (pour l'instant, ça a l'air com­pli­qué)
  • le pro­to­ty­page (c'est plus facile en Python)

On conti­nue­ra bien sûr à uti­li­ser d'autres lan­gages, ce qui est une bonne chose, mais je pense que Rust a le (super) pou­voir de rem­pla­cer Java et C++ comme lan­gage pour le cal­cul inten­sif dans le futur. Et faire gagner beau­coup de temps a beau­coup de monde.

(Re)?sources intéressantes

Le site du pro­jet : https://​www​.rust​-lang​.org/

L'article Léa Linux : http://​lea​-linux​.org/​d​o​c​u​m​e​n​t​a​t​i​o​n​s​/​R​ust
L'article Wiki­pé­dia
Apprendre le Rust : http://​doc​.rust​-lang​.org/​b​o​ok/
Le pro­jet Rust-bio : https://​github​.com/​r​u​s​t​-​b​i​o​/​r​u​s​t​-​bio
Confé­rence sur Ser­vo : https://​www​.you​tube​.com/​w​a​t​c​h​?​v​=​7​q​9​v​I​M​X​S​Tzc
OS en Rust : http://​www​.redox​-os​.org/
Le chan IRC fran­co­phone Rust-fr : irc://irc.mozilla.org/rust-fr
Awe­some Rust : https://​github​.com/​k​u​d​1​i​n​g​/​a​w​e​s​o​m​e​-​r​ust

_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​_​

Un grand mer­ci aux relec­teurs, Bun­ny, Beba­but, Maxi_​Zu et lroy pour les cor­rec­tions d'un article qui fut long à fina­li­ser !




Commentaires

6 réponses à “Rust, un super héros au secours de la bio-informatique ?”

  1. Petite ques­tion inno­cente : quelle dif­fé­rence impor­tantes trou­vez vous entre Go et Rust ? Go est éga­le­ment proche de C/​C+ et intègre de façon trans­pa­rente le paral­lé­lisme ?

    Rust a même l'air plus "com­pli­qué" dans l'écriture. J'y vois du pour (ça amè­ne­rait le pro­gram­meur a pro­duire du code moins bug­gé) et du contre (temps et com­plexi­té d'écriture, inves­tis­se­ment plus consé­quent en for­ma­tion).

    1. Pierre Marijon
      Pierre Marijon

      C'est une ques­tion très déli­cate, les deux lan­gages on été ren­du publique à peu près au même moment avec a peu près les mêmes objec­tifs (gros­siè­re­ment rem­pla­cer le Java et le C++) et par deux concur­rents. On va rapi­de­ment cas­ser le sus­pense je suis par­ti­san, je me suis plus inté­res­sé à Rust car je suis plus proche des idées défen­dues par Moz­zi­la, donc je connais mieux Rust que Go.

      Mais j'ai quand même un peu tes­té le Go. C'était dans le cadre d'un gros pro­jet donc il y avait déjà de la com­plexi­té, ce qui peut biai­sé mon juge­ment, mais j'ai le sen­ti­ment que les com­plexi­tés sont équi­va­lentes.

      Ensuite quelques incon­vé­nients qu'a le Go par rap­port au Rust en mon sens :

      - Le gabrage col­lec­tor, qui va for­ce­ment aug­men­ter la taille de votre pro­gramme, son temps d’exécution et sa consom­ma­tion de mémoire. Mais en contre par­tie on *peut* gagner du temps de déve­lop­pe­ment. Et sur­tout ça empêche au déve­lop­peur d'avoir une ges­tion fine de sa mémoire, même si cette pos­si­bi­li­té amène sou­vent des bugs, Rust les résoud de manière plus élé­gante.
      — La ges­tion des dépen­dances. Car­go va créé tout seul comme un grand un .car­go dans votre $HOME et y ran­ger vos dépen­dances. En Go il faut créé une variable d’environnement pour que Go sache où aller chercher/​installer ces dépen­dances, je trouve que c'est un peu plus lourd l’environnement de déve­lop­pe­ment et plus long à mettre en place.
      — Le Go n'est pas UNIX, Rust l'est plus. La com­mande go fait tout for­ma­tage du code/​compilation/​gestion des dépen­dances. rustc n'est que le com­pi­la­teur, car­go ne fait que la ges­tion de pro­jet, j'apprécie ce décou­plage.

      En véri­fiant mes argu­ments pour cette réponse j'ai lu https://​en​.wiki​pe​dia​.org/​w​i​k​i​/​G​o​_​(​p​r​o​g​r​a​m​m​i​n​g​_​l​a​n​g​u​a​g​e​)​#​O​m​i​s​s​i​ons et effec­ti­ve­ment il y a un cer­tain nombre d'omissions qui me semble injus­ti­fié, notam­ment la pro­gram­ma­tion géné­rique.

      Voi­là j'espère avoir été clair et que tu as bien com­pris que Rust est meilleur que le Go d'abord.

  2. Et un autre point impor­tant, le Rust a plus de para­digmes. Du fonc­tion­nel à l'objet en pas­sant par l'impératif et sans oublier le concur­rent… certes, il y a beau­coup de para­digmes exis­tants, mais ceux-là ont tous de gros avan­tages, et pou­voir les com­bi­ner est tel­le­ment pra­tique…

    1. Pierre Marijon
      Pierre Marijon

      Pour le coup j'ai envie de dire que c'est un avan­tage et un incon­vé­nient pour l'adoption du lan­gage :

      Un avan­tage car effec­ti­ve­ment plus de fonc­tion­na­li­té, plus de bon­heur, on peut faire plus de chose avec le lan­gage, ça va être plus facile de faire cer­taines choses, etc …

      Un incon­vé­nient car ça rend plus dif­fi­cile l'adoption du lan­gage, le lan­gage va être plus com­plexe, et on va prendre plus de temps a le maî­tri­sé, et donc il y aura moins de déve­lop­peur.

  3. Salut.

    Super article.

    Petite erreur détec­tée dans l'explication du pas­sage par réfé­rence (quand tu parles de l'ownership )

    /​/​ le mot clef return est impli­cite en Rust

    => oui… mais seule­ment si tu vires le ";" der­rière val pour que ça reste une expres­sion. Avec le point vir­gule, ça devient un sta­te­ment et la fonc­tion ne retour­ne­ra rien du tout ! La, ça ne fonc­tionne pas.

    Bisous

  4. Mer­ci effec­ti­ve­ment tu rai­son j'applique un cor­rec­tif le plus rapi­de­ment pos­sible.

Laisser un commentaire