Rust (langage)

Un article de Wikipédia, l'encyclopédie libre.
(Redirigé depuis Rust (Mozilla))
Aller à : navigation, rechercher
Page d'aide sur l'homonymie Pour les articles homonymes, voir Rust et Mozilla.
Rust
Logo.

Date de première version Voir et modifier les données sur Wikidata
Paradigmes impératif, Objet, fonctionnel, concurrent
Auteur Graydon Hoare
Développeurs Mozilla
Dernière version 1.20.0 ()[1]Voir et modifier les données sur Wikidata
Version en développement 0.1 ()[2]Voir et modifier les données sur Wikidata
Typage Fort, Statique
Influencé par C++, Erlang, Haskell, Scala, OCaml...
Système d'exploitation Multiplate-forme
Licence Apache-2.0 (d)[3] et licence MIT[4]Voir et modifier les données sur Wikidata
Site web www.rust-lang.orgVoir et modifier les données sur Wikidata
Extension de fichier rsVoir et modifier les données sur Wikidata

Rust est un langage de programmation compilé multi-paradigme conçu et développé par Mozilla Research[5]. Il a été conçu pour être « un langage sécurisé, concurrent, pratique »[6],[7], supportant les styles de programmation purement fonctionnel, modèle d'acteur, procédural et orienté objet.

Le langage s'est développé à partir d'un projet personnel du développeur en chef Graydon Hoare, qui commença à travailler dessus en 2006. Son employeur Mozilla commença sa participation en 2009[8] et révéla officiellement leurs travaux pour la première fois en 2010[9]. La même année, le projet passa du compilateur initialement utilisé (écrit en OCaml) au compilateur auto-hébergé écrit en Rust[10]. Ce compilateur, connu sous le nom de rustc, s'est compilé avec succès en 2011[11]. Le compilateur auto-hébergé utilise LLVM pour son Backend.

La première version alpha numérotée du compilateur Rust apparait en janvier 2012[12].

Du fait de la politique de Mozilla[13], Rust est entièrement développé de façon ouverte (les ingénieurs de Mozilla Research publient leurs idées et les décisions prises lors des réunions) et sollicite les remarques et contributions de la communauté. La conception du langage est graduellement améliorée au travers des retours de l'équipe travaillant sur le moteur de rendu Ce lien renvoie vers une page d'homonymie Servo[14] et de façon pragmatique lors de l'écriture du compilateur. Bien que le projet soit financé par Mozilla et Samsung, la majorité des contributions proviennent de la communauté.

Description[modifier | modifier le code]

Question book-4.svg
Cette section ne cite pas suffisamment ses sources (août 2016)
Pour l'améliorer, ajoutez des références vérifiables [comment faire ?] ou le modèle {{Référence nécessaire}} sur les passages nécessitant une source.

Le but de Rust est de devenir un langage efficace pour la création de larges logiciels clients et serveurs reposant sur Internet. Cet objectif a mené à l'intégration de fonctionnalités accentuant la sécurité, le contrôle de la mémoire et la concurrence. Les performances du code Rust en mode sécuritaire tendent à être moindres que celles du code C++ si lesdites performances sont les seules considérations. Toutefois, lorsque l'on fait la comparaison avec un code C++ qui utilise manuellement les mêmes précautions sécuritaires que Rust, les performances sont comparables.

La syntaxe du langage est similaire à celle du C, étant constituée de blocs de code délimités par des accolades et de structures de contrôle comme if, else, while et for. Tous les mots-clés du C ne sont pas réservés par le langage, cependant, et certaines formes propres aux langages fonctionnels, comme les blocs match permettant le filtrage par motif, pourraient déconcerter les développeurs arrivant de langages strictement impératifs ou orientés-objets. Ainsi, malgré leur ressemblance syntaxique, Rust est sémantiquement très différent du C ou du C++.

Le système a notamment été conçu pour garantir la désallocation de la mémoire. Ainsi, il ne permet pas, par exemple, les pointeurs null ou encores des références à de la mémoire déjà désallouée. Les variables peuvent seulement être initialisées par un nombre limité de formes, requérant toutes que les variables soient initialisées avant leur utilisation. Un système de durée de vie et gel des pointeurs permet au compilateur de prévenir plusieurs types d'erreurs communes en C++, même lors de l'utilisation de pointeurs intelligents.

En mars 2017 la Fondation Mozilla a mis à disposition la V1.6 avec la sous-commande cargo check pour les développeurs, elle permet un gain de temps lors du test d'écriture sans génération du code binaire[15].

Points forts[modifier | modifier le code]

Rust repose sur des concepts connus et éprouvés (d'où le nom Rust, « la rouille » en anglais) et n'intègre pas de concepts nouveaux et non testés[16]. Ces concepts ont été empruntés à des langages de programmation existants et assemblés dans un seul langage[17] :

Rust est souvent décrit comme l'un des successeurs potentiels de C++ (avec D et, dans une moindre mesure, Go) notamment grâce à sa sûreté — c'est un objectif clairement affiché par les développeurs.

Projets basés sur Rust[modifier | modifier le code]

Exemples de code[modifier | modifier le code]

Hello world :

1 // This is the main function
2 fn main() {
3     // The statements here will be executed when the compiled binary is called
4 
5     // Print text to the console
6     println!("Hello World!");
7 }

Arrays and Slices :

 1 use std::mem;
 2 
 3 // This function borrows a slice
 4 fn analyze_slice(slice: &[i32]) {
 5     println!("first element of the slice: {}", slice[0]);
 6     println!("the slice has {} elements", slice.len());
 7 }
 8 
 9 fn main() {
10     // Fixed-size array (type signature is superfluous)
11     let xs: [i32; 5] = [1, 2, 3, 4, 5];
12 
13     // All elements can be initialized to the same value
14     let ys: [i32; 500] = [0; 500];
15 
16     // Indexing starts at 0
17     println!("first element of the array: {}", xs[0]);
18     println!("second element of the array: {}", xs[1]);
19 
20     // `len` returns the size of the array
21     println!("array size: {}", xs.len());
22 
23     // Arrays are stack allocated
24     println!("array occupies {} bytes", mem::size_of_val(&xs));
25 
26     // Arrays can be automatically borrowed as slices
27     println!("borrow the whole array as a slice");
28     analyze_slice(&xs);
29 
30     // Slices can point to a section of an array
31     println!("borrow a section of the array as a slice");
32     analyze_slice(&ys[1 .. 4]);
33 
34     // Out of bound indexing yields a panic
35     println!("{}", xs[5]);
36 }

Références[modifier | modifier le code]

  1. https://blog.rust-lang.org/2017/08/31/Rust-1.20.html
  2. https://mail.mozilla.org/pipermail/rust-dev/2012-January/001256.html
  3. https://github.com/rust-lang/rust/blob/master/COPYRIGHT
  4. https://github.com/rust-lang/rust/blob/master/COPYRIGHT
  5. (en) « The Rust Language », Lambda the Ultimate, (consulté le 30 octobre 2010).
  6. (en) « The Rust Programming Language » (consulté le 21 octobre 2012).
  7. (en) « Doc language FAQ » (consulté le 21 octobre 2012).
  8. (en) « Project FAQ », (consulté le 11 janvier 2012).
  9. (en) « Future Tense », (consulté le 6 février 2012) : « At Mozilla Summit 2010, we launched Rust, a new programming language motivated by safety and concurrency for parallel hardware, the “manycore” future which is upon us. »
  10. (en) Graydon Hoare, « Rust Progress », (consulté le 30 octobre 2010).
  11. (en) Graydon Hoare, « [rust-dev] stage1/rustc builds », (consulté le 20 avril 2011) : « After that last change fixing the logging scope context bug, looks like stage1/rustc builds. Just shy of midnight :) ».
  12. (en) catamorphism, « Mozilla and the Rust community release Rust 0.1 (a strongly-typed systems programming language with a focus on memory safety and concurrency) », (consulté le 6 février 2012).
  13. (en) « The Mozilla Manifesto » (consulté le 9 avril 2012).
  14. (en) Peter Bright, « Samsung teams up with Mozilla to build browser engine for multicore machines », (consulté le 4 avril 2013).
  15. fredericmazue, « Sortie de Rust 1.6 », Programmez! n° 205, sur Programmez!, (consulté le 21 mars 2017)
  16. « Présentation de Rust sur Léa-Linux » (consulté le 11 décembre 2013).
  17. « Sortie de Rust 0.8 » (consulté le 15 octobre 2013).
  18. « Shipping Rust in Firefox ★ Mozilla Hacks – the Web developer blog », sur hacks.mozilla.org (consulté le 19 octobre 2016)
  19. (en) Cade Metz, « The Epic Story of Dropbox’s Exodus From the Amazon Cloud Empire », WIRED,‎ (lire en ligne)

Annexes[modifier | modifier le code]

Liens externes[modifier | modifier le code]