Rust Développez des programmes robustes et sécurisés
Présentation
Ce livre sur le langage Rust s'adresse en premier lieu aux développeurs connaisseurs du C/C++, voire de langages comme Python ou C#, désireux d'apprendre ce langage adapté à la programmation système sécurisée.
Les premiers chapitres permettent de rendre accessible le propos, non seulement à un public issu du monde C++, mais également à un public connaisseur du développement logiciel via un langage plus éloigné. Ainsi, les concepts fondamentaux du langage sont étudiés, notamment la gestion de la mémoire impliquant le tas (heap) et la pile (stack). Les notions centrales en Rust que sont la propriété et l'emprunt font également l'objet de larges développements. La gestion de la mémoire est également abordée du point de vue de l'usage du multithreading.
Puis, au fil de la lecture, vous explorez également les notions de modules et de caisses (crates), de structures, d’énumérations et de filtrage par motif ainsi que les traits, les closures et les principales collections utilisées en Rust. Un chapitre est également consacré à la notion de WebAssembly, ainsi qu'un autre aux notions avancées en Rust.
Des éléments complémentaires sont en téléchargement sur le site www.editions-eni.fr.
Quizinclus dans
la version en ligne !
Les premiers chapitres permettent de rendre accessible le propos, non seulement à un public issu du monde C++, mais également à un public connaisseur du développement logiciel via un langage plus éloigné. Ainsi, les concepts fondamentaux du langage sont étudiés, notamment la gestion de la mémoire impliquant le tas (heap) et la pile (stack). Les notions centrales en Rust que sont la propriété et l'emprunt font également l'objet de larges développements. La gestion de la mémoire est également abordée du point de vue de l'usage du multithreading.
Puis, au fil de la lecture, vous explorez également les notions de modules et de caisses (crates), de structures, d’énumérations et de filtrage par motif ainsi que les traits, les closures et les principales collections utilisées en Rust. Un chapitre est également consacré à la notion de WebAssembly, ainsi qu'un autre aux notions avancées en Rust.
Des éléments complémentaires sont en téléchargement sur le site www.editions-eni.fr.
Quizinclus dans
la version en ligne !
- Testez vos connaissances à l'issue de chaque chapitre
- Validez vos acquis
Table des matières
Comment et pourquoi Rust ?
- 1. Introduction
- 2. Contexte d'invention et nature du langage Rust
- 3. Pourquoi le langage Rust ?
- 3.1 La question de la gestion de la mémoire
- 3.1.1 La pile
- 3.1.2 Le tas
- 3.1.3 Le typage sûr
- 3.1 La question de la gestion de la mémoire
- 3.2 La question de la gestion concurrentielle des threads
- 3.2.1 Contexte d'utilisation du parallélisme
- 3.2.2 Situation de compétition
- 3.2.3 L'enfer de l'exclusion mutuelle
Commençons à utiliser concrètement Rust
- 1. Installation et exploration
- 1.1 L'outil rustup
- 1.2 L'outil central : cargo
- 1.2.1 Versions installées
- 1.2.2 Un premier projet
- 1.2.3 Analyse et explications relatives au premier projet
- 1.2.4 Commandes principales cargo
- 2.1 Un premier exemple de programme Rust
- 2.2 Exécution du programme
- 2.3 Compléments apportés au programme
- 3.1 Un mot sur les tests unitaires en Rust
- 3.2 Un mot sur l'organisation par module
- 3.3 Un mot sur la ligne de commande
- 4.1 Introduction
- 4.2 Petit lexique du langage Rust
- 4.2.1 Mutabilité
- 4.2.2 Structure (struct)
- 4.2.3 Trait et générique
- 4.2.4 Caisse (crate) et module
- 4.2.5 Propriété et emprunt
Types, structures de données en Rust
- 1. Introduction
- 2. Les types primitifs simples
- 2.1 Types numériques entiers
- 2.1.1 Entiers signés
- 2.1.2 Entiers non signés
- 2.1.3 Entiers codés d'après la taille du processeur
- 2.1 Types numériques entiers
- 2.2 Types numériques flottants
- 2.3 Le type booléen
- 2.4 Le type char
- 3.1 Le tuple
- 3.2 La structure struct
- 3.2.1 Structure, cas général
- 3.2.2 Structure et mutabilité
- 3.2.3 Le tuple structure
- 4.1 Références en Rust
- 4.2 Boîte (box) en Rust
- 4.3 Pointeurs bruts (raw pointers) en Rust
- 5.1 Introduction
- 5.2 Les tableaux en Rust
- 5.3 Les vecteurs en Rust
- 5.4 Les tranches en Rust
- 6.1 Introduction
- 6.2 Cas pratique autour de string
Possession et emprunt en Rust
- 1. Introduction
- 1.1 Le tas et la pile
- 1.2 Utilité de la possession
- 2. Fonctionnement de la possession
- 2.1 Grands principes
- 2.2 Exemples relatifs à la propriété
- 2.2.1 Propriété dans le tas
- 2.2.2 Propriété dans la pile
- 2.3 Plus loin avec la propriété : usage avec fonctions
- 2.3.1 Passage de valeur à une fonction
- 2.3.2 Retour de fonction
- 2.4 Conclusion à propos de la possession
- 3.1 Introduction
- 3.2 Exemple : transfert de propriété vs emprunt
- 3.2.1 Transfert de propriété
- 3.2.2 Emprunt
Structures en Rust
- 1. Premières structures en Rust
- 1.1 Introduction
- 1.2 Structure à champs nommés
- 1.2.1 Syntaxe
- 1.2.2 La question de la visibilité
- 1.3 Structure - tuple
- 1.4 Structure - unité
- 1.5 Un mot de l'implantation mémoire d'une structure
- 2.1 Prototype des méthodes
- 2.2 Usage du mot-clé self
- 2.3 Un exemple d'utilisation des méthodes
- 2.4 Vers les méthodes statiques en Rust
- 3.1 Introduction
- 3.2 Exemple support
- 3.3 Exemple support augmenté
- 4.1 Introduction
- 4.2 Mise en évidence du besoin d'annotation de durée de vie
- 4.3 Durée de vie basée sur le mot-clé static
- 5.1 Introduction
- 5.2 Les traits prédéfinis appliqués aux structures
Énumérations et motifs en Rust
- 1. Introduction
- 2. Les énumérations en Rust
- 2.1 Premiers exemples
- 2.2 Exemple de conversion d'entiers vers une énumération
- 2.2.1 Les options dans la librairie standard
- 2.2.2 Premiers filtrages par motif
- 2.3 Un mot sur les méthodes d'énumération
- 2.4 Utiliser des structures dans des énumérations
- 2.4.1 Introduction
- 2.4.2 Exemple d'utilisation
- 2.5 Les énumérations génériques
- 2.5.1 Exemple dans la librairie standard
- 2.5.2 Arbre binaire avec une énumération générique
- 3.1 Premier exemple, pour rappel
- 3.2 Plus loin avec les motifs
Les traits en Rust
- 1. Introduction
- 2. Premier trait en Rust
- 2.1 Création d'une caisse et d'un exécutable client
- 2.2 Définition d'un trait
- 3. Utiliser un trait en paramètre
- 3.1 Introduction
- 3.2 Exemple de trait en paramètre
- 3.3 Plusieurs paramètres d'un même trait en paramètre
- 4. Notion de trait lié
- 4.1 Introduction
- 4.2 Plusieurs traits liés différents pour un même paramètre
- 4.2.1 Introduction
- 4.2.2 Le trait prédéfini Display
- 4.2.3 Création de la structure Tortue
- 4.2.4 Un mot sur la clause where
- 5.1 Introduction
- 5.2 Exemple support
- 6.1 Traits, génériques et structures
- 6.2 Un mot sur les sous-traits
Les traits prédéfinis en Rust
- 1. Introduction
- 2. Des traits prédéfinis essentiels : les itérateurs
- 3. Notion de surcharge d'opérateurs
- 3.1 Introduction
- 3.2 Les opérateurs surchargeables
- 3.3 Exemple support
- 3.3.1 Contexte des nombres complexes
- 3.3.2 Premiers éléments de programmation
- 3.3.3 Surcharges des opérateurs + et -
- 3.3.4 Surcharges de la comparaison
- 4.1 L'usage de Derive
- 4.1.1 Explications
- 4.1.2 Exemple support
- 4.2.1 Introduction
- 4.2.2 Le trait Drop
- 4.2.3 Les traits Deref et DerefMut
- 4.2.4 Le trait Default
- 4.2.5 Le trait From
Les chaînes de caractères en Rust
- 1. Introduction
- 2. Encodages Unicode et UTF-8 et caractères en Rust
- 2.1 Quelques définitions
- 2.2 Encodage en Rust
- 2.2.1 Le type char et l'Unicode
- 2.2.2 Les types String et str et l'UTF-8
- 3.1 Nature des caractères
- 3.2 Casse des caractères
- 3.3 Conversion vers un entier
- 4.1 Introduction
- 4.2 Le type str
- 4.3 Le type String
- 4.3.1 Construction du type
- 4.3.2 Création d'un String
- 4.3.3 Premiers outils autour de String
- 4.3.4 Insertion dans un String
- 4.3.5 Suppression avec un String
- 4.3.6 Recherche et remplacement dans un String
Les vecteurs en langage Rust
- 1. Introduction
- 2. Le vecteur Vec<T>
- 2.1 Introduction
- 2.2 Accès aux éléments (référence et copie)
- 2.3 Méthodes avancées d'accès
- 2.4 Considérations sur la taille et la capacité
- 2.5 Ajouts et retraits de valeurs
- 2.6 Autres opérations sur vecteurs
- 2.7 Un mot sur le tri de vecteurs
- 2.8 Un mot sur la recherche dans un vecteur
Autres collections en langage Rust
- 1. Introduction
- 2. La collection VecDeque<T>
- 2.1 Présentation
- 2.2 Utilisation de VecDeque<T>
- 3. La collection LinkedList<T>
- 3.1 Présentation
- 3.2 Utilisation simple de LinkedList<T>
- 4. La collection BinaryHeap<T>
- 4.1 Présentation
- 4.2 Utilisation de BinaryHeap<T>
- 5. Table de hachage HashMap<Key, Value>
- 5.1 Présentation
- 5.2 Utilisation de HashMap<Key, Value>
- 5.3 Un mot sur la collection BTreeMap<Key, Value>
- 6. Approche ensembliste avec HashSet<T>
- 6.1 Présentation
- 6.2 Utilisation de HashSet<T>
- 6.3 Un mot sur la collection BTreeSet<T>
- 7. Conclusion
Les closures en Rust
- 1. Introduction
- 2. Considérations théoriques
- 3. Première utilisation d'une closure
- 4. Tri facile avec une closure
- 5. Les closures, résumé des premières notions
- 6. Considérations sur les traits FnOnce, FnMut et Fn
- 6.1 Explications du fonctionnement général
- 6.2 Le mot-clé move
Les threads et le multithreading en Rust
- 1. Introduction
- 2. Premiers threads et parallélisme
- 2.1 Introduction
- 2.2 Usage de spawn
- 2.2.1 Introduction
- 2.2.2 Premier exemple concret
- 2.3 Attendre la fin des threads secondaires (Fork-Join)
- 2.4 L'alternative rayon
- 2.4.1 Premier exemple
- 2.4.2 Un peu de parallélisme
- 3.1 Introduction
- 3.2 Usage des canaux en Rust
- 3.2.1 Définition
- 3.2.2 Première utilisation d'un canal
- 3.2.3 Considérations sur la sécurisation du canal
- 3.2.4 Envois multiples dans le canal
- 4.1 Présentation et définition
- 4.2 Les structures Rc et Arc
- 4.2.1 Introduction
- 4.2.2 Rc<T>
- 4.2.3 Arc<T>
Rust et WebAssembly
- 1. Introduction
- 1.1 Première considération
- 1.2 Explications de WebAssembly
- 2. Exemple détaillé de WebAssembly
- 2.1 Installation d'outils
- 2.2 Exemple détaillé
- 2.2.1 Introduction
- 2.2.2 Développement côté Rust
- 2.2.3 Développement côté JavaScript
- 3.1 Quelques caisses utiles
- 3.1.1 Caisse wasm-bindgen
- 3.1.2 Caisse console_error_panic_hook
- 3.1.3 Caisse console_log
- 3.2.1 Introduction
- 3.2.2 Déploiement sur npm
Notions avancées en Rust
- 1. Introduction
- 2. Les objets-traits
- 2.1 Présentation
- 2.2 La surcharge statique
- 2.3 La surcharge dynamique
- 2.3.1 Introduction
- 2.3.2 Contexte de l'exemple
- 2.3.3 Définition d'un trait dédiée à la surcharge dynamique
- 2.3.4 Usage du mot-clé dyn
- 3.1 Introduction
- 3.2 Déréférencer un pointeur brut
- 3.3 Modifier une variable statique mutable
- 3.4 Implémenter des traits non sécurisés
Projet final : coder et publier une caisse
- 1. Introduction
- 2. Périmètre fonctionnel
- 3. Développement Rust de la librairie
- 4. Autres aspects et tests de la caisse
- 5. Publication de la caisse
- Index
Auteur
Benoît PRIEUREn savoir plus
Diplômé de l'ISIMA de Clermont-Ferrand, Benoît PRIEUR a exercé pendant plusieurs années en tant qu'ingénieur freelance. Spécialisé dans le développement avec les langages Python, C++, Rust et C#, il est aujourd’hui Ingénieur innovation pour le compte du cabinet international de conseil en innovation Palo IT. Également formateur et conférencier sur diverses technologies (relatives notamment à l'informatique quantique), il écrit régulièrement des articles sur la programmation de logiciels.
Caractéristiques
- Niveau Confirmé à Expert
- Nombre de pages 362 pages
- Parution mai 2022
- Livre (broché) - 17 x 21 cm
- ISBN : 978-2-409-03528-9
- EAN : 9782409035289
- Ref. ENI : EIRUST
- Niveau Expert à Confirmé
- Parution mai 2022
- HTML
- ISBN : 978-2-409-03529-6
- EAN : 9782409035296
- Ref. ENI : LNEIRUST
Téléchargements
- Des fichiers complémentaires (31 870 Ko)