URL: https://linuxfr.org/news/rust-a-5-ans-retrospective
Title: Rust a 5 ans, rétrospective
Authors: StyMaar
 Aldebaran, Ysabeau 🧶, bubar🦥, Lawless, Anonyme, Cetera, Yves Bourguignon, Sylvestre Ledru, ariasuni, palm123, M5oul, olivierweb, BAud, abriotde, Xavier Teyssier, karchnu, Davy Defaud, esdeem, thomasv, Papey, ZeroHeure, thoasm, cpm, Bruno Michel, Benoît Sibaud, Leirda et redfoxx7
Date: 2018年08月28日T09:57:00+02:00
License: CC By-SA
Tags: rust, debian et firefox
Score: 91
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.org_ 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` et `await` était une des tâches 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é de la recherche de motifs (_pattern matching_). L’introduction du « _rest pattern_ » permet de vérifier la correspondance 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 Fondation Mozilla 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 de la 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 concurrents à 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 bogues 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 "Common Vulnerabilities and Exposures — informations publiques relatives aux vulnérabilités de sécurité") 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 un débordement de tampon (_buffer overflow_). 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 rationnelles 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 facilement le lien 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 plate‐forme é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) étaient codés 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 bibliothèques, 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 et de construction 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 GNU/Linux ont empaqueté le compilateur Rust et Cargo, ainsi que 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 cadriciels 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‐plate‐forme 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 JavaScript, ou bien [Deno (EN)](https://deno.land/), un possible successeur de [Node.js (EN)](https://nodejs.org/en/).
Par ailleurs, [il a été question d’intégrer du Rust dans le noyau Linux](https://lkml.org/lkml/2020/7/9/952). L’idée pourrait attirer de [nouveaux développeurs qui ne veulent pas forcément faire du C (EN)](https://www.theregister.com/2020/06/30/hard_to_find_linux_maintainers_says_torvalds/).
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 de 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](https://doc.rust-lang.org/book/) » (EN) 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, 2^(nd) 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/) !
</div><div class="naked_ctrl">
<form action="/index.cgi/contrast" method="get" name="gate">
<p><a href="http://altstyle.alfasado.net">AltStyle</a> によって変換されたページ <a href="httpS://linuxfr.org/news/rust-a-5-ans-retrospective.md">(-&gt;オリジナル)</a>
/ <label>アドレス: <input type="text" name="naked_post_url" value="httpS://linuxfr.org/news/rust-a-5-ans-retrospective.md" size="22" /></label> <label>モード: <select name="naked_post_mode">
<option value="default">デフォルト</option>
<option value="speech">音声ブラウザ</option>
<option value="ruby">ルビ付き</option>
<option value="contrast" selected="selected">配色反転</option>
<option value="larger-text">文字拡大</option>
<option value="mobile">モバイル</option>
</select>
<input type="submit" value="表示" />
</p>
</form>
</div>