URL: https://linuxfr.org/news/rust-a-5-ans-retrospective Title: Rust a 5 ans, rétrospective Authors: StyMaar Aldebaran, Ysabeau, bubar, Lawless, SamWang-9, Yves Bourguignon, Sylvestre Ledru, Cetera, ariasuni, palm123, M5oul, olivierweb, abriotde, BAud, Xavier Teyssier, karchnu, eggman, thomasv, Leirda, Thomas Douillard, Bruno Michel, cpm, Papey et redfoxx7 Date: 2018-08-28T09:57:00+02:00 License: CC By-SA Tags: rust et langage_rust Score: 4 Rust est un langage de programmation développé principalement par Mozilla. La première version stable, la [1.0](https://blog.rust-lang.org/2015/05/15/Rust-1.0.html), est sortie en 2015. La dernière version disponible à ce jour est la [1.46.0](https://blog.rust-lang.org/2020/08/27/Rust-1.46.0.html), publiée le 27 août 2020. Dépourvu de [ramasse-miettes](https://fr.wikipedia.org/wiki/Ramasse-miettes_(informatique)), il permet une gestion fine de la mémoire, de manière sécurisée pour prévenir les erreurs de segmentation. Il garantit aussi la sécurité des fils d’exécution (_thread safety_). Ces caractéristiques en font un langage sûr et performant. Ses bonnes performances, comparables à celles du C et du C++, le rendent particulièrement adapté à la _programmation système_. Ainsi, il est utilisable dans un grand nombre de situations où ces deux langages étaient habituellement utilisés : noyau de système d’exploitation, services de systèmes, embarqué, moteurs de jeu vidéo 3D, etc. Cette dépêche se propose de revenir sur son histoire, courte mais riche, et d’examiner la situation présente. ---- [Rust en 2018](https://blog.rust-lang.org/2018/07/27/what-is-rust-2018.html) [Liste et évolution des contributeurs pour chaque version publiée](https://thanks.rust-lang.org) [Réécriture en Rust d'outils courants en ligne de commande ](https://zaiste.net/posts/shell-commands-rust/) ---- # Retours sur les évolutions de Rust depuis sa sortie Rust a été largement couvert sur LinuxFr.org, à travers les versions [0.7](https://linuxfr.org/users/guiea_7/journaux/sortie-de-rust-0-7), [0.8](https://linuxfr.org/news/presentation-de-rust-0-8), [0.9](https://linuxfr.org/news/quelques-nouvelles-sur-rust-a-l-occasion-de-la-0-9), [0.10](https://linuxfr.org/news/rust-s-oxyde-en-version-0-10), [0.11](https://linuxfr.org/news/encore-une-couche-de-rouille-avec-rust-0-11), [0.12](https://linuxfr.org/news/rust-0-12-non-pas-le-jeu-video-le-langage), [1.0-alpha](https://linuxfr.org/news/le-langage-rust-en-version-1-0-alpha-on-arrete-de-tout-casser). Le 15 mai 2015, la première version stable de Rust était publiée [1.0](https://linuxfr.org/news/rust-1-0-entree-dans-la-periode-stable), les versions [1.1, 1.2 et 1.3](https://linuxfr.org/news/rust-versions-1-1-1-2-et-1-3), l'[édition 2018](https://linuxfr.org/news/l-edition-2018-de-rust-est-sortie). L’année 2020 marque les cinq ans du langage, et à cette occasion la fondation Mozilla a publié un [récapitulatif des principales améliorations (EN)](https://blog.rust-lang.org/2020/05/15/five-years-of-rust.html) portées au langage ! En cinq ans le langage a donc beaucoup évolué, la version 2018 étant la dernière traitée sur LinuxFR une petite mise à jour s’impose. En 2019 ------- 1.33 - **Le Pinning** : il est parfois utile d’avoir la garantie qu’un objet ne bougera pas en mémoire, comme un objet ayant un pointeur sur lui-même qui serait invalidé en cas de changement d’adresse. Le type `Pin` assure que les données pointées par n’importe quel pointeur de type P ont une adresse stable, la donnée ne peut pas bouger ou être désallouée jusqu’à ce qu’on enlève le Pin. La donnée est dite « pinned ». 1.34 - **Des dépôts de Crates alternatifs pour Cargo** : le Rust est de plus en plus utilisé en production, il y a un besoin grandissant de dépôts privés. Cargo a toujours permis des dépendances via git mais avec les [Alternative Registries (EN)](https://boats.gitlab.io/blog/post/2017-10-28-alternative-registries/) une organisation peut facilement créer et partager son propre dépôt de _crates_, d’une façon similaire à [crates.io (EN)](https://crates.io/). 1.39 — **Async/Await, le futur est là** : la stabilisation des mots clefs async/await était une des taches majeures pour faire de Rust un langage de premier ordre. Tout juste six mois après sa libération, la programmation asynchrone se développe en un écosystème diversifié et performant. Notamment avec [Tokio (EN)](https://github.com/tokio-rs/tokio) ! Pour utiliser async-await, il faut commencer par ajouter async devant une fonction : ```rust async fn first_function() -> u32 { .. } ``` À la différence d’une fonction ordinaire, un appel à une `async fn` retourne un _Future_. C’est une opération en suspend qui attend qu’on lui dise de s’exécuter. Pour exécuter un _future_ on utilisera l’opérateur `.await` : ```rust async fn another_function() { // Create the future: let future = first_function(); // Await the future, which will execute it (and suspend // this function if we encounter a need to wait for I/O): let result: u32 = future.await; ... } ``` Dans cet exemple on utilise `future.await` en lieu et place de `await future` dans la plupart des langages, cela permet une meilleure intégration avec le mot clef `?` pour la gestion d’erreur. Vous pouvez simplement écrire `future.await ?`. Contrairement à d’autres langages l’implémentation des futures en Rust est dite sans coût, en effet les futures de Rust ne font rien à moins d’être interrogés. Dans d’autres langages, appeler une fonction asynchrone lance un futur qui commence à s’exécuter immédiatement. Pour plus de [détails (EN)](https://aturon.github.io/blog/2016/08/11/futures/) ! En 2020 ------- 1.42 — **Subslice patterns** : ce n’est pas le plus grand changement du langage mais c’était une fonctionnalité depuis longtemps attendue qui va améliorer le confort des développeurs et l’expressivité du _pattern matching_. L’introduction du « rest pattern » permet de matcher avec le reste d’un slice grâce au mot clef `..` , comme dans cet exemple : ```rust fn foo(words: &[&str]) { match words { // Ignore everything but the last element, which must be "!". [.., "!"] => println!("!!!"), // `start` is a slice of everything except the last element, which must be "z". [start @ .., "z"] => println!("starts with: {:?}", start), // `end` is a slice of everything but the first element, which must be "a". ["a", end @ ..] => println!("ends with: {:?}", end), rest => println!("{:?}", rest), } } ``` Cette liste n’est, bien entendu, pas du tout exhaustive, le langage s’est continuellement amélioré sur le plan de la stabilité, des performances et des fonctionnalités. Le compilateur est plus performant et un peu moins pointilleux, de nouvelles macros sont apparues, pour faciliter le débogage par exemple et tout un tas de petites fonctionnalités s’additionnent pour hisser le langage à un autre niveau. Le blog officiel en expose le [détail (EN)](https://blog.rust-lang.org/) ! Une autre grande annonce de 2020 est la création d’une fondation pour le langage. Créé et poussé par la Mozilla Fondation depuis ses débuts le langage s’offre une fondation en propre, la [Rust Fondation (EN)](https://blog.rust-lang.org/2020/08/18/laying-the-foundation-for-rusts-future.html). Au-delà des difficultés rencontrées récemment par Mozilla c’est avant tout une manière de rendre le projet plus autonome et indépendant des décisions d’un seul groupe. # Des chiffres ! En 2018, le dépôt [Rust (EN)](https://github.com/rust-lang/rust) sur GitHub compte plus de 87 000 commits et plus de 2 200 contributrices et contributeurs. Au niveau des statistiques spécifiques à GitHub, le projet est suivi par plus de 5 400 personnes et a été marqué d’une étoile par plus de 32 000 personnes. Il y a [plus de 28 000 dépôts sur GitHub (EN)](https://github.com/search?utf8=%E2%9C%93&q=language%3ARust+language%3ARust&type=Repositories&ref=advsearch&l=Rust) utilisant le langage Rust. Pour comparaison : * 1 428 dépôts lors de la sortie de la version 0.10 * 3 262 dépôts lors de la sortie de la version 0.12 * 4 892 dépôts lors de la sortie de la version 1.0-alpha * 7 000 dépôts lors de la sortie de la version 1.0 Toujours en 2018 Open Hub compte 650 projets en Rust, plus de 7 300 contributrices et contributeurs, près de 350 000 commits et plus de 11 300 000 lignes de code. Pour comparaison : * 121 projets lors de la sortie de la version 0.10 * 165 projets et 1 007 386 lignes de code lors de la sortie de la version 0.12 * 200 projets et 1 200 000 lignes de code lors de la sortie de la version 1.0 Ces chiffres montrent que depuis mai 2015 l’intérêt pour Rust a fortement crû. En 2020, le dépôt [Rust (EN)](https://github.com/rust-lang/rust) sur GitHub compte plus de 125 000 commits. # À qui s’adresse Rust ? Rust s’adresse aussi bien aux développeurs C et C++, qu’aux développeurs de langages de plus haut niveau qui souhaiteraient s’initier à la programmation système sans avoir à affronter les galères de gestion mémoire ou de gestion de dépendances. Il a trois avantages majeurs par rapport au C et au C++ : - il empêche les problèmes d’accès concurrent à la mémoire. Le code est alors facile à paralléliser, même dans des bases de code très volumineuses ; - grâce à son système de type évolué, il évite la plupart des bugs liés à la gestion de la mémoire que l’on retrouve dans un grand nombre de [CVE](https://fr.wikipedia.org/wiki/Common_Vulnerabilities_and_Exposures) de systèmes critiques : _use-after-free_ (utilisation [de la mémoire] après [sa] libération), _double free_ (double libération), _iterator invalidation_ (invalidation d’itérateur [lors du parcours d’un tableau]) ou encore _buffer overflow_ (débordement de tampon). Cette vérification s’effectue essentiellement à la compilation, mais certaines vérifications additionnelles sont également effectuées à l’exécution (_bound-checking_ (contrôle des bornes) sur les tableaux) ; - il dispose de fonctionnalités modernes dont ne disposent pas des langages plus anciens : une gestion simple et intuitive des dépendances (via l’outil `cargo`) et des fonctionnalités issues de la programmation fonctionnelle (_pattern-matching_, `map()`, `filter()`, `reduce()`, etc.), entre autres. De plus, puisqu’il ne nécessite pas d’environnement d’exécution, il est facile à interfacer avec des projets écrits dans d’autres langages comme [Python (EN)](https://developers.redhat.com/blog/2017/11/16/speed-python-using-rust/) ou Go, dans le but de bénéficier du maximum de performances sur une partie critique du code. Par exemple avec [cette bibliothèque (EN)](https://github.com/BurntSushi/rure-go) qui utilise le moteur d’expressions régulières de Rust depuis Go, améliorant significativement les performances par rapport à la version de la bibliothèque standard Go. Il existe d’ailleurs des bibliothèques qui permettent de faire le lien facilement entre le Rust et d’autres langages : [Ruru (EN)](https://github.com/d-unseductable/ruru) ou [Helix (EN)](https://usehelix.com/) pour le langage Ruby ; [Neon (EN)](https://github.com/neon-bindings/neon) pour écrire des modules natifs rapides et sûrs pour Node.js, la plateforme événementielle en JavaScript côté serveur ; [PyO3 (EN)](https://github.com/PyO3/PyO3) et [milksnake (EN)](https://github.com/getsentry/milksnake) pour le langage Python ; [Bindgen (EN)](https://github.com/rust-lang-nursery/rust-bindgen) pour les langages C et C++. # Adoption de Rust Rust a mis toutes les chances de son côté mais ses chances étaient bien minces de percer tant le problème est ardu. L’intérêt des informaticiens pour un langage de haut niveau performant et « sûr » est réel mais, pour les convaincre, il faut arriver à avoir un gain suffisant de performances par rapport à Python et un gain significatif dans la facilité de programmation par rapport au C++ sans être trop différent afin d’être adopté facilement. La sortie de Firefox 56 avec l’intégration de code Rust a propulsé l’intérêt du langage. Les performances du navigateur ont prouvé ses capacités. On sait maintenant qu’il est possible de coder en autre chose qu’en C/C++ avec des performances similaires pour le programme final. En juin 2020, [12% de Firefox (EN)](https://twitter.com/eroc/status/1287804986231894016) était codé en Rust. De la même manière Discord [bascule de Go à Rust](https://blog.discord.com/why-discord-is-switching-from-go-to-rust-a190bbca2b1f) pour son écosystème de librairie notamment en matière d’asynchronisme avec [Tokio (EN)](https://github.com/tokio-rs/tokio), sa gestion mémoire et ses performances globales. En plus de ces avantages techniques purs, comme un gestionnaire de paquet / builder quasiment magique : [Cargo (EN)](https://doc.rust-lang.org/stable/cargo/), le langage peut également compter sur un écosystème de bibliothèques foisonnant (_crates_ de leur petit nom, publiées sur [crates.io (EN)](https://crates.io/)) et qui est, de plus, de très bonne qualité. De nombreuses distributions Linux ont empaqueté le compilateur Rust et Cargo et différentes applications développées en utilisant Rust. Par exemple, Debian propose depuis sa dernière version stable (buster), [ripgrep (EN)](https://github.com/BurntSushi/ripgrep), [exa (EN)](https://github.com/ogham/exa) ou encore [fd (EN)](https://github.com/sharkdp/fd). Certains projets comme [Actix (EN)](https://actix.rs/) ou [Alacritty (EN)](https://github.com/alacritty/alacritty) démontrent les performances du langage, l’un en se hissant en haut du [Web Framework Benchmarks (EN)](https://www.techempower.com/benchmarks/#section=data-r18&hw=ph&test=fortune) de techempower, passant même devant des frameworks en C ou C++ tout en proposant des fonctionnalités de très haut niveau comme les _closures_, de l’asynchronisme ou du _pattern matching_ ! D’autres projets comme [Bevy (EN)](https://github.com/bevyengine/bevy), un moteur de jeu 2D/3D multi-plateforme sur le modèle Entité-Composant-Système) bien que très jeunes se constituent rapidement [une belle communauté (EN)](https://bevyengine.org/news/scaling-bevy/), signe qu’il y a une appétence des développeurs pour le langage. Le langage creuse aussi son trou dans d’autres projets où on l’attend moins, comme [npm (EN)](https://www.npmjs.com/) qui l’utilise en plus du JS, ou bien [Deno (EN)](https://deno.land/) un possible successeur de [Node.js (EN)](https://nodejs.org/en/). En conclusion ============= Que dire ? Le Rust est élégant, bien construit, dispose de fonctionnalités de haut niveau tout en restant très performant et même s’il a encore quelques lacunes, par exemple en ce qui concerne les interfaces graphiques (avec cependant de [bons candidats (EN)](https://www.areweguiyet.com/)), il n’en demeure pas moins très stable et tout à fait utilisable. Récemment les développeurs derrière Chromium et Chrome ont publié un [billet (EN)](https://www.chromium.org/Home/chromium-security/memory-safety/rust-and-c-interoperability) concernant la possible utilisation de Rust au sein de leur base de code, soulignant les gains ainsi que les défis que cela représente dans le cas très pointu et particulier qui est le leur. Pour avoir une petite idée de ce à quoi ressemble l’écosystème du Rust vous pouvez consulter cette [liste (EN)](https://github.com/rust-unofficial/awesome-rust) qui recense des applications, bibliothèques, outils et ressources jugées impressionnantes. Le langage est encore jeune, mais il promet, et le plus simple pour vous faire un avis c’est de l’essayer ! Allez sur le [site officiel (EN)](https://www.rust-lang.org/learn) du projet qui a une très bonne documentation, des cours et un [« Book » (EN)](https://doc.rust-lang.org/book/) très agréable à lire. Si vous préférez avoir du papier entre les mains, on trouve de bons bouquins, par exemple, en anglais, chez l’éditeur O’Reilly : [Programming Rust, 2nd Edition](https://www.oreilly.com/library/view/programming-rust-2nd/9781492052586/) et [The Rust Programming Language (Covers Rust 2018)](https://www.oreilly.com/library/view/the-rust-programming/9781098122539/) ou chez Eyrolles en français, [Programmer avec Rust](https://www.eyrolles.com/Informatique/Livre/programmer-avec-rust-9782412046593/). Vous pouvez même directement l’essayer en ligne si [ça vous dit (EN)](https://play.rust-lang.org/) !