Rust, mais pourquoi est-il si populaire ?


Publié le 14-01-2021 par Modérateur FREELANCE INFO



  

SDGfT3wmzO5gthJgEk1tG95GzWLBTKK_Xpee72d4guvqK_5VcUbzW3i6inxQAiDDXlw_szS4JQsEwZIazyL35cRu2ZD5IQw3ABpNV0iQYVAXRsvClvnIpi_JbtoRoxyFfimFfFLJ

 

Selon plusieurs enquêtes de Stackoverflow, Rust est le langage le plus apprécié par les développeurs depuis plusieurs années. Fruit d’un projet personnel de Graydon Hoare, ancien développeur chez Mozilla, sa première version stable a vu le jour en 2015. Depuis, il a connu un succès fulgurant jusqu’à entrer en 2020, dans le top 20 du classement TIOBE qui mesure la popularité des langages de programmation. 86% des développeurs qui l’ont testé souhaitent continuer à l'utiliser régulièrement. Mais pourquoi Rust est-il aussi populaire ?

Rust un langage puissant et sécurisé

Les performances du C

Rust est un langage de bas niveau, multi-paradigme, à typage statique et axé sur la sécurité qui offre des performances proches de celles des langages C et C++ et permet d’obtenir un binaire similaire.

Il comporte donc tous les avantages d'un langage de bas niveau avec une utilisation limitée de la mémoire vive et du processeur ainsi qu’un accès direct aux bibliothèques standards. Il est indépendant de tout environnement d’exécution et peut ainsi être utilisé dans des systèmes embarqués ou s'intégrer facilement à d'autres langages.

Par rapport aux langages managés de typage statique comme Java ou C#, il apporte une simplification importante de la programmation multithread. Il traite en effet les accès concurrentiels plus facilement grâce à un modèle de gestion de la mémoire particulièrement fiable.

C’est d’ailleurs l’objectif principal de Rust,créé pour être un « un langage fiable, concurrent, pratique ».

Une meilleure gestion de la mémoire et une sécurité accrue

Selon son créateur, le compilateur Rust est strict et garantit que la mémoire est utilisée en toute sécurité afin que les développeurs puissent se focaliser uniquement sur les problèmes de programmation.

Cela passe d’abord par le « vérificateur d'emprunt ». C'est-à-dire la partie du compilateur chargée de s'assurer que les pointeurs et références ne survivent pas aux données auxquelles elles se réfèrent. Cela prévient tout risque de fuite de mémoire.

Par exemple le code suivant ne compilera pas en Rust :

fn exemple_verif_emprunt() -> &String {
    // création d’une variable limitée à la portée de la fonction
    let phrase = String::from("hello World!");
    // on renvoie une référence qui pointe sur la variable (avec &)
    // sa portée est également limitée au scope de la fonction
   return  &phrase 
}
fn main() {
    let reference_vers_le_vide = exemple_verif_emprunt();
    //erreur retournée :  « missing lifetime specifier »

}Sur le même principe Rust permet d’éviter dès la compilation les :

-  erreurs de segmentation qui se produisent quand un programme tente d’accéder à une zone mémoire qui ne lui a pas été attribuée par le système d'exploitation (par exemple avec des pointeurs invalides ou des débordements de tableaux),

- situations de concurrence qui surviennent quand des tâches ou programmes simultanés tentent d’accéder aux mêmes données.

Il ne s’agit pas comme en Java d’un « garbage collector » (ou ramasse-miettes, un processus de libération de la mémoire des données inutilisées) qui intervient périodiquement ou à la demande.
Rust fonctionne sur un système de « propriété ». Chaque valeur appartient à une variable appelée son « propriétaire ».

Ces variables  « vivent» dans une portée (scope) limitée ce qui fait que la mémoire est libérée au fur et à mesure.

Avec ce principe, dans Rust, une seule variable peut posséder une certaine donnée. Si cette donnée est affectée à une autre variable, elle n’appartient plus à la première, par exemple :

let mut phrase1 = String::from("hello World!"); 
let mut phrase2 = phrase1 ;
 phrase1.push_str("ajout à la phrase initiale")
    //erreur avant la compilation

Le code précédent ne compilera pas car la propriété des données est déplacée vers la variable « phrase2 » et n'est plus accessible depuis « phrase1 ».

La syntaxe rigide et le typage fort de Rust permettent également de s’assurer qu’il n’y a pas de fuites de mémoire après la compilation.

Premier pas avec Rust

Une syntaxe simple

Rust est un langage bas niveau qui offre ainsi des performances élevées. En revanche, sa syntaxe, relativement simple à maîtriser, se rapproche de celle des langages fonctionnels comme Haskell.

Variables et mutabilité

En Rust, les variables se déclarent avec le mot clé « let ». À l’inverse, de la plupart des autres langages de programmation, en Rust, elles sont par défaut immuables.Pour les rendre mutables, il faut utiliser  le mot clé « mut ».

Cependant, ces variables ne sont pas des constantes, car elles restent limitées à leur portée. Pour déclarer une véritable constante à portée globale il faut employer le mot clé const :

const UNECONSTANTE: i32 = 10; //i32 désigne un type entier signé 32 bits

Les types de variables

Rust est un langage de typage statique, il faut donc que toutes les variables soient typées lors de la compilation. Cependant, le compilateur peut généralement déduire le type en fonction de la valeur de la variable et de la façon dont elle est utilisée.

Les types sont similaires à ceux qui peuvent être rencontrés dans la majorité des langages de programmation.

Par exemple pour un booléen la déclaration sera la suivante :
 

fn main() {
        let t = true; 
        let f: bool = false; // avec typage explicite
 }

 

Les fonctions

Les fonctions sont omniprésentes en Rust. Elles se déclarent avec « fn » et utilisent le «snake case » comme convention typographique,c’est-à-dire que toutes les lettres sont en minuscules et que les mots sont séparés par un underscore.

Par exemple :

 

n main() { 
        println!("Hello, world!");
         une_autre_fonction();
 } 
 
fn une_autre_fonction() {
 println!("Une autre fonction.");
 }
 

 

Boucles et comparaisons

Là aussi, les syntaxes de boucles et comparaisons sont relativement similaires à celles qui peuvent être rencontrées dans les autres langages. On retrouve donc « if et else », « for » mais surtout « match » qui permet de comparer une valeur à une série de valeurs :

fn main() {
let number = 13;
       println!("Entrez un numéro");
        match number {     
      	  1 => println!("One !"), // Comparaison avec une seule valeur
 
   	  2 | 3 | 5 => println!("Un nombre premier !"), // Comparaison avec plusieurs valeurs      
 
        	13..=19 => println!("Un adolescent !"),// Comparaison avec une intervalle
 
        _ => println!("Rien de spécial..."), // gère les autres cas
 
    }
 }

 

L’écosystème Rust

Les utilisations de Rust sont très variées et vont de la création et de la maintenance de logiciels, au codage de programmes scientifiques en passant par le développement de sites web.

Rust est également fourni avec « Cargo », un gestionnaire de paquets qui permet, entre autres, de gérer les dépendances, d’exécuter des tests, de générer de la documentation, et de créer des packages distribuables sur crates.io, le registre de packages de la communauté Rust.

Avec son succès grandissant, Rust bénéficie d’une importante communauté. Sur le site officiel de cette communauté, on peut retrouver de la documentation, des tests ,des outils de développement et bien sûr des forums et canaux thématiques de discussion.

De nombreuses conférences sont également organisées pour les développeurs Rust à travers le monde, telles que la « RustConf » ou «  Rust Belt Rust ».

Et vous, que pensez vous du langage Rust, avez-vous eu l’occasion de le tester ? N’hésitez pas à nous faire vos retours sur le forum !

Sources : 

Classement de StackOverflow : https://stackoverflow.blog/2020/01/20/what-is-rust-and-why-is-it-so-popular/

Documentation officielle de Rust : https://doc.rust-lang.org/rust-by-example/custom_types/constants.html



Modérateur FREELANCE INFO