7 raisons d'utiliser Rust pour votre prochain projet de développement

Reasons-to-Use-Rust-for-Your-Next-Development-Project

Vous êtes développeur et vous souhaitez apprendre le langage Rust ? Pour vous aider à prendre votre décision, cet article présente quelques-unes des caractéristiques de Rust, l’un des langages de programmation systémique les plus populaires.

Dans cet article, nous allons explorer le langage de programmation Rust et ses caractéristiques, telles que le système de types, la sécurité de la mémoire et la propriété. Nous passerons également en revue une liste de ressources qui peuvent vous aider à apprendre Rust.

Commençons !

Qu’est-ce que Rust ?

Rust est un langage de programmation système. Il a débuté en tant que projet personnel de Graydon Hoare, un développeur, en 2006. En moins d’une décennie, il s’est imposé comme le langage de référence pour la programmation de systèmes et les applications connexes. Le salaire moyen d’un programmeur Rust est d’environ 120 000 dollars.

Si vous souhaitez passer du C au Rust ou apprendre un nouveau langage, l’apprentissage du Rust peut donc être un excellent choix ! Selon l’enquête StackOverflow Developer Survey, Rust a été élu le langage de programmation le plus apprécié – pour la septième année consécutive.

Rust offre la rapidité des langages de programmation de systèmes de bas niveau tels que C et C et la sécurité des langages de programmation de haut niveau tels que Python.

De projets notables tels que Dropbox et Firefox à WebAssembly et à la programmation embarquée, Rust est largement utilisé dans tous les domaines du développement logiciel. Rust offre un support de gestion de paquets prêt à l’emploi grâce à Cargo.

Cargo : le gestionnaire de paquets pour Rust

Cargo est le gestionnaire de paquets pour Rust. Vous pouvez utiliser Cargo pour installer des paquets à partir de crates, le registre de paquets de Rust. En plus d’être un gestionnaire de paquets qui vous permet de rechercher, d’installer et de gérer des paquets, Cargo sert également d’exécuteur de tests, de générateur de documentation et de système de construction.

Maintenant que vous avez une vue d’ensemble de Rust, examinons de plus près certaines de ses caractéristiques qui en font un langage de programmation de systèmes largement adopté.

Messages d’erreur utiles

En tant que programmeur débutant, vous rencontrerez des erreurs et passerez beaucoup de temps à déboguer votre code. Vous utiliserez les messages d’erreur et les avertissements fournis par le compilateur pour résoudre ces problèmes. Des messages utiles peuvent vous aider à déboguer plus rapidement.

Exemple de message d’erreur

Lorsque votre code ne se compile pas correctement, Rust fournit des messages d’erreur utiles qui expliquent ce qui doit être corrigé dans votre code et à quel endroit.

Dans cet exemple, la variable num2 est définie à l’intérieur de la fonction inner(). Elle est donc limitée à la portée de la fonction. Si vous essayez d’y accéder en dehors de la fonction, le compilateur lance une erreur :

fn main() {
 let num1 = 10 ;
 fn inner(){
 let num2 = 9 ; 
 }
 println !("La valeur de num2 est : {}", num2) ;
}

Et le message d’erreur donne des informations sur ce qui doit être corrigé.

error[E0425] : cannot find value `num2` in this scope
 -->
 src/main.rs:6:42
 |
6 | println !("The value of num2 is : {}", num2) ;
 | ^^^^ help : il existe une variable locale avec un nom similaire : `num1`

Avertissements pendant la compilation

Le compilateur fournit également des avertissements utiles concernant des problèmes dans votre code. Lorsque vous définissez des variables mais que vous ne les utilisez jamais dans le reste du programme, Rust vous envoie un message d’avertissement, comme indiqué ci-dessous.

fn main() {
 let num1 = 10 ;
 let num2 = 9 ;
 println !("La valeur de num1 est : {}", num1) ;
}

Ici, la variable num2 est déclarée mais n’est jamais utilisée.

warning : unused variable : `num2`
 -->
 src/main.rs:3:9
 |
3 | let num2 = 9 ;
 | ^^^^ help : si c'est intentionnel, préfixez-la avec un trait de soulignement : `_num2`
 |

Langage fortement typé

Une autre raison pour laquelle vous devriez utiliser Rust pour vos projets de développement est son système de types. Rust est un langage fortement typé, ce qui signifie qu’il ne supporte pas la coercition de type. On parle de coercition de type lorsqu’un langage peut implicitement convertir une valeur d’un type de données en un autre.

Par exemple, le code Python dans la cellule de code suivante s’exécutera sans erreur. En effet, en Python, un nombre non nul a une valeur de vérité de True et, par conséquent, l’instruction if s’exécute sans erreur, même si le nombre 10 est un entier et non un booléen.

num1 = 10
if num1 :
 num2 = 9
print(f "num2 is {num2}")

# Output : num2 is 9

D’un autre côté, Rust ne contraint pas les types. Le code suivant va donc générer une erreur :

fn main() {
 let num1 = 10 ;
 if num1{
 let num2 = 9 ; 
 }
}

L’erreur signale une incompatibilité de type, alors qu’un booléen était attendu et qu’un entier a été trouvé.

error[E0308] : mismatched types
 -->
 src/main.rs:3:8
 |
3 | if num1{
 | ^^^^ expected `bool`, found integer

Sécurité de la mémoire

La sécurité de la mémoire est une autre caractéristique de Rust qui le rend attrayant pour les programmeurs. Nous allons essayer de vous donner un bref aperçu de son fonctionnement.

Les variables doivent être initialisées avant d’être utilisées

En Rust, toutes les variables doivent être initialisées avant de pouvoir être utilisées. Dans des langages tels que le C, le code suivant, où num n’est pas initialisé, se compilera et s’exécutera sans erreur. La valeur de la variable non initialisée est une valeur poubelle.

#include <stdio.h>

int main(void) {
 int num ;
printf("The value of num is %d", num) ;
return 0 ;
}
// Output : La valeur de num est 0

Si vous essayez de faire quelque chose de similaire en Rust, vous rencontrerez une erreur à la compilation. Rust n’a donc pas de notion de garbage collection.

fn main() {
 let num:i32 ;
 println !("La valeur de num est : {}",num) ;
}

error[E0381] : used binding `num` isn't initialized
 -->
 src/main.rs:3:40
 |
2 | let num:i32 ;
 | --- binding declared here but left uninitialized
3 | println !("The value of num is : {}",num) ;
 | ^^^ `num` used here but it is not initialized
 |

Sécurité de la mémoire à la compilation

Rust assure la sécurité de la mémoire au moment de la compilation. Prenons un exemple simple. Ici, même si l’instruction conditionnelle if a une valeur booléenne de true, ce qui signifie que la valeur de num sera toujours 100, nous obtenons une erreur lorsque nous essayons d’imprimer la valeur de num.

fn main() {
 let num:i32 ;
 if true{
 num = 100 ;
 }
 println !("La valeur de num est : {}", num) ;
}

En effet, l’évaluation conditionnelle a lieu au moment de l’exécution et le compilateur n’est pas en mesure de garantir que num a une valeur au moment de la compilation.

error[E0381] : used binding `num` is possibly-uninitialized
 -->
 src/main.rs:6:41
 |
2 | let num:i32 ;
 | --- binding declared here but left uninitialized
3 | if true{
 | ---- if this `if` condition is `false`, `num` is not initialized
4 | num = 100 ;
5 | }
 | - un bras `else` pourrait manquer ici, initialisant `num`
6 | println !("La valeur de num est : {}", num) ;
 | ^^^ `num` est utilisé ici mais il est possible qu'il ne soit pas initialisé

Si vous regardez de plus près le message d’erreur, vous verrez qu’avec une instruction else, nous pouvons nous assurer que num aura une valeur. Le code suivant s’exécutera donc sans erreur. De cette façon, le compilateur peut déterminer que num aura une valeur – au moment de la compilation – de sorte qu’il n’y a pas d’erreurs.

fn main() {
 let num:i32 ;
 if true{
 num = 100 ;
 }
 else{
 num = 50 ;
 }
 println !("La valeur de num est : {}", num) ;
}

La valeur de num est : 100

Immutabilité des variables

Il est également utile de noter que les variables en Rust sont immuables par défaut. Cela signifie qu’en tant que développeur, vous n’avez pas à vous soucier d’écraser accidentellement la valeur d’une variable particulière. Voici un exemple :

fn main() {
 let num1 = 10 ;
 num1 = 5 ;
 println !("La valeur de num1 est : {}", num1) ;
}

Comme num1 est initialisé à 10, lorsque vous essayez de lui attribuer une valeur de 5, vous obtenez un message d’erreur qui dit “cannot assign twice to immutable variable num1” (Impossible d’attribuer deux fois la variable immuable num1).

error[E0384] : cannot assign twice to immutable variable `num1`
 -->
 src/main.rs:3:5
 |
2 | let num1 = 10 ;
 | ----
 | |
 | first assignment to `num1`
 | help : consider making this binding mutable : `mut num1`
3 | num1 = 5 ;
 | ^^^^^^^^ ne peut pas assigner deux fois une variable immuable

Propriété et emprunt

La propriété assure la sécurité de la mémoire. Fonctionnellement, la propriété en Rust peut être résumée comme suit :

Chaque objet doit avoir un et un seul propriétaire. Si le propriétaire sort du champ d’application, l’objet est abandonné.

Prenons un exemple simple. Ici, nous initialisons une chaîne de caractères str1 et déplaçons ensuite sa valeur dans str2. Comme tout objet ne peut avoir qu’un seul propriétaire, l’objet str1 est supprimé dès que sa valeur est déplacée vers str2.

fn main() {
 let str1 = String::from("Rust") ;
 let str2 = str1 ;
 println !("La valeur de str1 est : {}", str1) ;
}

error[E0382] : borrow of moved value : `str1`
 -->
 src/main.rs:4:42
 |
2 | let str1 = String::from("Rust") ;
 | ---- move occurs because `str1` has type `String`, which does not implement the `Copy` trait
3 | let str2 = str1 ;
 | ---- value moved here
4 | println !("La valeur de str1 est : {}", str1) ;
 | ^^^^ valeur empruntée ici après le déplacement

Bien que cela semble intuitif, pour mieux comprendre et apprécier le fonctionnement de la propriété, il est utile d’apprendre les concepts d’emprunt et de référence.

Développement rapide

Jusqu’à présent, nous avons discuté de plusieurs fonctionnalités utiles du langage de programmation Rust. En voici quelques-unes :

Rust est optimisé pour la vitesse et la sécurité.
Il est livré avec un outil de gestion de paquets intégré et construit un système.
Il dispose également d’une riche bibliothèque standard.

En substance, Rust offre tout ce qu’un développeur peut demander. Par conséquent, avec Rust, vous pouvez développer des applications rapidement avec un débogage minimal et des constructions plus rapides.

Développement multiplateforme

Avec Rust, vous pouvez choisir de développer sur la plateforme de votre choix. Rust prend en charge les plateformes les plus courantes : Linux, MacOS et Windows.

Le développement d’applications est généralement facile, car vous pouvez compiler le code source Rust en un exécutable sans dépendre d’autres outils de construction ou de compilateurs externes.

Communauté de soutien

Une communauté qui vous soutient contribue grandement à simplifier votre parcours d’apprentissage. Rust a une énorme base d’utilisateurs qui ne fait que croître d’année en année.

La popularité de Rust dans l’enquête StackOverflow auprès des développeurs indique qu’il existe une grande communauté d’utilisateurs, avec de nombreux développeurs expérimentés prêts à partager leurs connaissances et leur expertise.

Outre la documentation officielle, il existe également un site de documentation générée par les utilisateurs et un forum de discussion. Vous pouvez également consulter le subreddit Rust et les groupes LinkedIn pour des discussions pertinentes.

Ressources d’apprentissage pour débuter avec Rust

Learning-Resources-to-Get-Started-With-Rust

Cette section présente quelques ressources utiles pour vous aider à démarrer avec Rust. Il ne s’agit pas d’une liste exhaustive, mais elle comprend des tutoriels, des cours et des livres recommandés pour vous aider dans votre apprentissage.

#1. Rust par l’exemple

Rust By Example vous enseignera les principes fondamentaux de Rust et les bibliothèques standard à travers une série d’exemples que vous pouvez coder dans un éditeur en ligne.

Les sujets couverts incluent les crates, cargo : l’outil de gestion des paquets pour Rust, les génériques, les traits, la gestion des erreurs, et bien plus encore.

#2. Rustlings

Rustlings est une autre ressource d’apprentissage officielle pour le langage de programmation Rust. Il est similaire à Rust par l’exemple. Cependant, il vous demande de mettre en place votre environnement de développement local, de cloner un repo d’exemple et de résoudre des problèmes simples pour apprendre ces concepts.

#3. La piste Rust d’Exercism

La piste Rust sur Exercism contient plus de 100 exercices pour vous aider à apprendre et à tester votre compréhension de Rust. Exercism est une plateforme gratuite où vous pouvez être encadré par des programmeurs expérimentés en plus de coder votre chemin à travers les exercices.

#4. Ultimate Rust Crash Course

L’Ultimate Rust Crash Course enseigné par Nathan Stocks sur Udemy couvre les points suivants :

Les bases de la programmation en Rust
Système de modules en Rust
Types de données et flux de contrôle
Références et emprunts
Structs, traits et collections

#5. Ultimate Rust 2 : Concepts intermédiaires

UltimateRust 2 est un cours qui fait suite au Ultimate Rust Crash Course et couvre les sujets suivants :

Les fermetures
Les itérateurs
Gestion des erreurs
Tests unitaires et d’intégration
Logging, multithreading, et canaux

#6. Rust lang : Le guide complet du débutant 2023

Ce cours Udemy enseigné par Catalin Stefan est un cours complet sur la programmation Rust. Voici quelques-uns des sujets abordés :

Principes fondamentaux de Rust
Types de données, structures de contrôle
Fonctions, traits
Gestion de la mémoire
La concurence

#7. Programmation en rouille : Développement de systèmes rapides et sûrs

Aperçu	Produit	Evaluation	Prix
	Programming Rust: Fast, Safe Systems Development		$43.99	Buy on Amazon

Programming Rust par O’Reilly est un livre de programmation Rust populaire qui vous apprendra ce qui suit :

Les types de données fondamentaux
Propriété et emprunt
Programmation asynchrone
Applications multithreading rapides
Fermetures, itérateurs
Collections

#8. Le langage de programmation Rust, 2e édition

Aperçu	Produit	Evaluation	Prix
	The Rust Programming Language, 2nd Edition		$36.52	Buy on Amazon

Le langage de programmation Rust est écrit par des contributeurs renommés de la communauté Rust. Ce livre couvre tout ce que vous devez savoir sur Rust, y compris :

La propriété et l’emprunt
Génériques, traits
Pointeurs intelligents, multithreading
Les tests et la gestion des erreurs

#9. Le guide de référence complet de la programmation en rouille

Aperçu	Produit	Evaluation	Prix
	The Complete Rust Programming Reference Guide: Design, develop, and deploy effective software…		$51.99	Buy on Amazon

Le Complete Rust Programming Reference Guide de Packt couvre les points suivants :

Implémentation de structures de données en Rust
Écrire des composants réutilisables et testables en Rust
Conception d’applications multithread Conception d’algorithme et
Les applications de Rust dans WebAssembly, les réseaux et les applications en ligne de commande

#10. Projets créatifs pour les programmeurs Rust

Aperçu	Produit	Evaluation	Prix
	Creative Projects for Rust Programmers: Build exciting projects on domains such as web apps,…		$44.99	Buy on Amazon

Si vous êtes un développeur expérimenté et que vous apprenez le langage Rust, il vous suffira de créer quelques projets dans votre domaine d’intérêt pour acquérir une bonne maîtrise du langage. Creative Projects for Rust Programmers de Packt est un livre qui enseigne Rust en l’appliquant à des projets tels que :

Construire des services web “Restful
jeux en 2D avec
Développement d’applications web avec WebAssembly
Émulateurs de langage machine
et bien plus encore !

Conclusion

Cet article a présenté une vue d’ensemble de Rust en tant que langage de programmation de systèmes, y compris des caractéristiques telles que la sécurité de la mémoire, la gestion améliorée des paquets, et plus encore. Nous avons également énuméré des ressources d’apprentissage pour vous aider à démarrer avec Rust.

Pour l’étape suivante, vous pouvez choisir une ou plusieurs des ressources d’apprentissage mentionnées pour apprendre les bases de Rust. Bonne programmation en Rust !

Vous pouvez également explorer les meilleurs fournisseurs d’hébergement de serveurs Rust.

Bala Priya C

Auteur