Introduction

Note : cette édition du livre est identique à The Rust Programming Language disponible en format papier et numérique chez No Starch Press.

Bienvenue dans Le langage de programmation Rust, un livre d’introduction à Rust. Le langage de programmation Rust vous aide à écrire des logiciels plus rapides et plus fiables. L’ergonomie de haut niveau et le contrôle de bas niveau sont souvent en opposition dans la conception des langages de programmation ; Rust remet en question ce conflit. En équilibrant une puissante capacité technique et une excellente expérience de développement, Rust vous donne la possibilité de contrôler les détails de bas niveau (comme l’utilisation de la mémoire) sans toutes les contraintes traditionnellement associées à ce type de contrôle.

À qui s’adresse Rust

Rust est idéal pour de nombreuses personnes et pour des raisons variées. Examinons quelques-uns des groupes les plus importants.

Les équipes de développeurs

Rust s’avère être un outil productif pour la collaboration au sein de grandes équipes de développeurs avec des niveaux variés de connaissances en programmation système. Le code de bas niveau est sujet à divers bugs subtils, qui dans la plupart des autres langages ne peuvent être détectés qu’au travers de tests approfondis et de revues de code minutieuses par des développeurs expérimentés. En Rust, le compilateur joue un rôle de gardien en refusant de compiler le code contenant ces bugs insaisissables, y compris les bugs de concurrence. En travaillant avec le compilateur, l’équipe peut consacrer son temps à se concentrer sur la logique du programme plutôt qu’à traquer des bugs.

Rust apporte également des outils de développement modernes au monde de la programmation système :

• Cargo, le gestionnaire de dépendances et outil de compilation intégré, rend l’ajout, la compilation et la gestion des dépendances simples et cohérents à travers tout l’écosystème Rust.
• L’outil de formatage rustfmt assuré un style de code cohérent entre les développeurs.
• Le Rust Language Server alimente l’intégration avec les environnements de développement intégrés (IDE) pour la complétion de code et les messages d’erreur en ligne.

En utilisant ces outils et d’autres dans l’écosystème Rust, les développeurs peuvent être productifs tout en écrivant du code au niveau système.

Les étudiants

Rust s’adresse aux étudiants et à ceux qui souhaitent apprendre les concepts système. Grâce à Rust, de nombreuses personnes ont appris des sujets comme le développement de systèmes d’exploitation. La communauté est très accueillante et se fait un plaisir de répondre aux questions des étudiants. À travers des initiatives comme ce livre, les équipes Rust souhaitent rendre les concepts système plus accessibles à un plus grand nombre de personnes, en particulier celles qui débutent en programmation.

Les entreprises

Des centaines d’entreprises, grandes et petites, utilisent Rust en production pour une variété de tâches, notamment des outils en ligne de commande, des services web, des outils DevOps, des systèmes embarqués, de l’analyse et du transcodage audio et vidéo, des cryptomonnaies, de la bio-informatique, des moteurs de recherche, des applications pour l’Internet des objets, de l’apprentissage automatique, et même des parties majeures du navigateur web Firefox.

Les développeurs open source

Rust s’adresse aux personnes qui veulent contribuer au langage de programmation Rust, à sa communauté, à ses outils de développement et à ses bibliothèques. Nous serions ravis que vous contribuiez au langage Rust.

Les personnes qui valorisent la vitesse et la stabilité

Rust s’adresse aux personnes qui recherchent la vitesse et la stabilité dans un langage. Par vitesse, nous entendons à la fois la rapidité d’exécution du code Rust et la rapidité avec laquelle Rust vous permet d’écrire des programmes. Les vérifications du compilateur Rust garantissent la stabilité lors de l’ajout de fonctionnalités et du refactoring. Cela contraste avec le code hérité fragile dans les langages dépourvus de ces vérifications, que les développeurs ont souvent peur de modifier. En visant des abstractions à coût nul — des fonctionnalités de haut niveau qui compilent en code de bas niveau aussi rapide que du code écrit manuellement — Rust s’efforce de faire en sorte que le code sûr soit également du code rapide.

Le langage Rust espère également prendre en charge de nombreux autres utilisateurs ; ceux mentionnés ici ne sont que quelques-unes des parties prenantes les plus importantes. Globalement, la plus grande ambition de Rust est d’éliminer les compromis que les programmeurs ont acceptés pendant des décennies en offrant la sûreté et la productivité, la vitesse et l’ergonomie. Essayez Rust et voyez si ses choix vous conviennent.

À qui s’adresse ce livre

Ce livre suppose que vous avez déjà écrit du code dans un autre langage de programmation, mais ne fait aucune supposition sur lequel. Nous avons essayé de rendre le contenu largement accessible aux personnes venant d’horizons de programmation variés. Nous ne passons pas beaucoup de temps à parler de ce qu’est la programmation ou de comment y réfléchir. Si vous êtes complètement novice en programmation, il serait préférable de lire un livre qui offre spécifiquement une introduction à la programmation.

Comment utiliser ce livre

En général, ce livre suppose que vous le lisez dans l’ordre, du début à la fin. Les chapitres ultérieurs s’appuient sur les concepts des chapitres précédents, et les chapitres précédents pourraient ne pas approfondir un sujet particulier mais y reviendront dans un chapitre ultérieur.

Vous trouverez deux types de chapitres dans ce livre : des chapitres conceptuels et des chapitres de projet. Dans les chapitres conceptuels, vous apprendrez un aspect de Rust. Dans les chapitres de projet, nous construirons ensemble de petits programmes, en appliquant ce que vous avez appris jusque-là. Les chapitres 2, 12 et 21 sont des chapitres de projet ; les autres sont des chapitres conceptuels.

Le chapitre 1 explique comment installer Rust, comment écrire un programme “Hello, world!” et comment utiliser Cargo, le gestionnaire de paquets et outil de compilation de Rust. Le chapitre 2 est une introduction pratique à l’écriture d’un programme en Rust, dans laquelle vous construirez un jeu de devinette de nombre. Nous y abordons les concepts à un haut niveau, et les chapitres ultérieurs fourniront des détails supplémentaires. Si vous voulez mettre les mains dans le cambouis tout de suite, le chapitre 2 est l’endroit idéal. Si vous êtes un apprenant particulièrement méticuleux qui préfère apprendre chaque détail avant de passer au suivant, vous voudrez peut-être sauter le chapitre 2 et aller directement au chapitre 3, qui couvre les fonctionnalités de Rust similaires à celles d’autres langages de programmation ; ensuite, vous pourrez revenir au chapitre 2 quand vous souhaiterez travailler sur un projet en appliquant les détails que vous aurez appris.

Au chapitre 4, vous découvrirez le système de possession (ownership) de Rust. Le chapitre 5 traite des structures (structs) et des méthodes. Le chapitre 6 couvre les énumérations (enums), les expressions match et les constructions de flux de contrôle if let et let...else. Vous utiliserez les structures et les énumérations pour créer des types personnalisés.

Au chapitre 7, vous apprendrez le système de modules de Rust et les règles de visibilité pour organiser votre code et son interface de programmation applicative (API) publique. Le chapitre 8 présente certaines structures de données de collection courantes fournies par la bibliothèque standard : les vecteurs, les chaînes de caractères et les tables de hachage. Le chapitre 9 explore la philosophie et les techniques de gestion des erreurs en Rust.

Le chapitre 10 approfondit les génériques, les traits et les durées de vie (lifetimes), qui vous donnent le pouvoir de définir du code applicable à plusieurs types. Le chapitre 11 est entièrement consacré aux tests, qui même avec les garanties de sûreté de Rust sont nécessaires pour s’assurer que la logique de votre programme est correcte. Au chapitre 12, nous construirons notre propre implémentation d’un sous-ensemble des fonctionnalités de l’outil en ligne de commande grep qui recherche du texte dans des fichiers. Pour cela, nous utiliserons de nombreux concepts abordés dans les chapitres précédents.

Le chapitre 13 explore les fermetures (closures) et les itérateurs : des fonctionnalités de Rust issues des langages de programmation fonctionnelle. Au chapitre 14, nous examinerons Cargo plus en profondeur et parlerons des bonnes pratiques pour partager vos bibliothèques avec d’autres. Le chapitre 15 traite des pointeurs intelligents (smart pointers) fournis par la bibliothèque standard et des traits qui permettent leur fonctionnement.

Au chapitre 16, nous parcourrons différents modèles de programmation concurrente et verrons comment Rust vous aide à programmer avec plusieurs fils d’exécution (threads) sans crainte. Au chapitre 17, nous poursuivrons en explorant la syntaxe async et await de Rust, ainsi que les tâches (tasks), les futures et les flux (streams), et le modèle de concurrence léger qu’ils permettent.

Le chapitre 18 examine comment les idiomes Rust se comparent aux principes de programmation orientée objet que vous connaissez peut-être. Le chapitre 19 est une référence sur les motifs (patterns) et le filtrage par motif (pattern matching), qui sont des moyens puissants d’exprimer des idées dans les programmes Rust. Le chapitre 20 contient un assortiment de sujets avancés intéressants, incluant le Rust unsafe, les macros, et davantage sur les durées de vie, les traits, les types, les fonctions et les fermetures.

Au chapitre 21, nous terminerons un projet dans lequel nous implémenterons un serveur web multithreadé de bas niveau !

Enfin, certaines annexes contiennent des informations utiles sur le langage dans un format plus proche d’une référence. L’annexe A couvre les mots-clés de Rust, l’annexe B couvre les opérateurs et symboles de Rust, l’annexe C couvre les traits dérivables fournis par la bibliothèque standard, l’annexe D couvre certains outils de développement utiles, et l’annexe E explique les éditions de Rust. Dans l’annexe F, vous trouverez des traductions du livre, et dans l’annexe G nous verrons comment Rust est développé et ce qu’est Rust nightly.

Il n’y a pas de mauvaise façon de lire ce livre : si vous voulez sauter des chapitres, n’hésitez pas ! Vous devrez peut-être revenir aux chapitres précédents si vous rencontrez des difficultés. Mais faites ce qui vous convient.

Une part importante du processus d’apprentissage de Rust est d’apprendre à lire les messages d’erreur affichés par le compilateur : ils vous guideront vers un code fonctionnel. Ainsi, nous fournirons de nombreux exemples qui ne compilent pas, accompagnés du message d’erreur que le compilateur vous montrera dans chaque situation. Sachez que si vous saisissez et exécutez un exemple au hasard, il pourrait ne pas compiler ! Assurez-vous de lire le texte environnant pour voir si l’exemple que vous essayez d’exécuter est censé produire une erreur. Dans la plupart des situations, nous vous guiderons vers la version correcte de tout code qui ne compilé pas. Ferris vous aidera également à distinguer le code qui n’est pas censé fonctionner :

Ferris	Signification
	Ce code ne compilé pas !
	Ce code panique !
	Ce code ne produit pas le comportement souhaité.

Dans la plupart des situations, nous vous guiderons vers la version correcte de tout code qui ne compilé pas.

Code source

Les fichiers sources à partir desquels ce livre est généré se trouvent sur GitHub.