Rust (langage)

Un article de Wikipédia, l'encyclopédie libre.

Rust
Logo.
Image illustrative de l’article Rust (langage)

Date de première version Voir et modifier les données sur Wikidata
Paradigmes Impératif, fonctionnel, concurrent
Auteur Graydon Hoare
Développeurs Rust Project, Rust Foundation (en)
Dernière version 1.76.0 ()[1]Voir et modifier les données sur Wikidata
Typage Fort, statique
Influencé par C++, Erlang, Haskell, Scala, OCaml, Scheme, Swift, C#, Alef, Limbo[2]
A influencé Swift[3], V[4], Zig[5]
Système d'exploitation Multiplate-forme
Licence Licence Apache version 2.0[6],[7] et licence MIT[6],[7]Voir et modifier les données sur Wikidata
Site web www.rust-lang.orgVoir et modifier les données sur Wikidata
Extensions de fichiers .rs, .rlib

Rust est un langage de programmation compilé multi-paradigme qui met l'accent sur la performance, la sûreté des types et la concurrence. Il assure la sécurité mémoire (en), ce qui signifie que toutes les références pointent vers une mémoire valide, sans nécessiter l'utilisation de techniques de gestion de la mémoire automatisée telles que le ramasse-miettes. Afin d'assurer la sécurité de la mémoire et d'empêcher une situation de compétition aux données, son "vérificateur d'emprunts" suit la durée de vie des objets de toutes les références dans un programme pendant la compilation. Rust a été influencé par des idées issues de la programmation fonctionnelle, notamment immutabilité, fonction d'ordre supérieur et les type algébriques. Il est populaire pour la programmation système[8],[9],[10].

Graydon Hoare, développeur de logiciels, a créé Rust en tant que projet personnel alors qu'il travaillait à Mozilla Research en 2006. Mozilla a officiellement parrainé le projet en 2009. Dans les années qui ont suivi la première version stable en mai 2015, Rust a été adopté par des entreprises telles que Amazon, Discord, Dropbox, Google (Alphabet), Meta, et Microsoft. En décembre 2022, il est devenu le premier langage autre que le C et l'assembleur à être pris en charge dans le développement du noyau Linux[11].

Rust a été remarqué pour son adoption rapide[12], et a été étudié dans le cadre de la recherche sur la théorie des langages de programmation[13],[14],[15].

Histoire[modifier | modifier le code]

Origines (2006-2012)[modifier | modifier le code]

Rust est né d'un projet personnel initié en 2006 par Graydon Hoare, employé de Mozilla Research[16]. Mozilla a commencé à parrainer le projet en 2009 dans le cadre du développement continu d'un moteur de navigateur expérimental appelé Servo[17], qui a été officiellement annoncé par Mozilla en 2010 [18],[19]. Au cours de la même année, le travail est passé du compilateur initial écrit en OCaml à un compilateur auto-hébergé basé sur LLVM écrit en Rust. Le nouveau compilateur Rust a réussi à se compiler lui-même en 2011[17].

Évolution (2012-2019)[modifier | modifier le code]

Le système de types de Rust a subi des changements importants entre les versions 0.2, 0.3 et 0.4. Dans la version 0.2, publiée en mars 2012, les classes ont été introduites pour la première fois[20]. Quatre mois plus tard, la version 0.3 ajoute les destructeurs et le polymorphisme, grâce à l'utilisation d'interfaces[21]. En octobre 2012, la version 0.4 a été publiée, ajoutant traits comme moyen d'héritage. Les interfaces ont été combinées avec les traits et supprimées en tant que fonctionnalité séparée ; et les classes ont été remplacées par une combinaison d'implémentations et de types structurés[22].

Au début des années 2010, la gestion de la mémoire par le système de propriété a été progressivement consolidée pour éviter les bogues de mémoire. En 2013, le ramasse-miettes a été supprimé, avec les règles de propriété en place[16].En janvier 2014, le rédacteur en chef du Dr. Dobb's Journal (en), Andrew Binstock, a commenté les chances de Rust de devenir un concurrent de C++, au même titre que D, Go, et Nim. Selon Binstock, alors que Rust était "largement considéré comme un langage remarquablement élégant", l'adoption a ralenti parce qu'il changeait radicalement d'une version à l'autre[23]. La première version stable, Rust 1.0, a été annoncée le 15 mai 2015[24],[25].

Le développement du moteur de navigation Servo s'est poursuivi parallèlement à la propre croissance de Rust. En septembre 2017, Firefox 57 a été publié en tant que première version intégrant des composants de Servo, dans un projet nommé "Firefox Quantum"[26].

Les licenciements de Mozilla et la Fondation Rust (2020-présent)[modifier | modifier le code]

En août 2020, Mozilla a licencié 250 de ses 1 000 employés dans le monde, dans le cadre d'une restructuration de l'entreprise causée par la pandémie de COVID-19[27],[28].L'équipe à l'origine de Servo a été dissoute. L'événement a soulevé des inquiétudes quant à l'avenir de Rust, car certains membres de l'équipe étaient des contributeurs actifs à Rust[29]. La semaine suivante, la Rust Core Team a reconnu l'impact sévère des licenciements et a annoncé que des plans pour une fondation Rust étaient en cours. Le premier objectif de la fondation serait de prendre possession de toutes les marques déposées et de tous les noms de domaine, et d'assumer la responsabilité financière de leurs coûts[30].

Le 8 février 2021, la formation de la Rust Foundation a été annoncée par ses cinq entreprises fondatrices (AWS, Huawei, Google, Microsoft, et Mozilla)[31],[32]. Dans un blog publié le 6 avril 2021, Google a annoncé le support de Rust au sein du Android Open Source Project comme alternative à C/C++ [33].

Le 22 novembre 2021, l'équipe de modération, qui était chargée de faire respecter les normes de la communauté et le Code de conduite, a annoncé sa démission "pour protester contre le fait que l'équipe principale ne rende de comptes à personne d'autre qu'à elle-même"[34]. En mai 2022, l'équipe principale de Rust, d'autres programmeurs principaux et certains membres du conseil d'administration de la Fondation Rust ont mis en œuvre des réformes de gouvernance en réponse à l'incident[35].

La Fondation Rust a publié le 6 avril 2023 un projet de nouvelle politique de marque déposée, révisant ses règles sur la façon dont le logo et le nom Rust peuvent être utilisés, ce qui a entraîné des réactions négatives de la part des utilisateurs et des contributeurs de Rust[36].

Caractéristiques[modifier | modifier le code]

Syntaxe[modifier | modifier le code]

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.

Cependant, la sémantique de Rust est assez différente. En effet, les blocs et les structures de contrôle sont des expressions, comme on peut le voir dans l'exemple :

let x = if n < 10 { n } else { n - 10 };

En C, une telle opération n'est pas « intelligible » pour le compilateur ; il faudra soit encapsuler le bloc conditionnel dans une autre fonction, soit utiliser un opérateur ternaire int x = (n < 10) ? n : n - 10;.

L'utilisation d'expressions rapproche ainsi Rust de langages fonctionnels comme Haskell ou OCaml.

Valeur et mutabilité[modifier | modifier le code]

Dans la plupart des langages, une variable est modifiable par défaut. Rust inverse cette logique en privilégiant la constance : le mot-clé let déclare par défaut des variables immuables (immutable variable en anglais) qui ne peuvent être affectées qu'une seule fois, mais dont la valeur peut être définie au moment de l'exécution. Il est nécessaire de rajouter le mot-clé mut pour rendre une variable « mutable » ou « muable » : ainsi, on restreint les variables qui sont effectivement autorisées à changer. Le type des variables est inféré à chaque fois que c'est possible.

Pour les valeurs constantes connues à la compilation, le mot-clé const remplace let. Leur type doit être précisé et elles doivent être initialisées à partir d'une expression constante, excluant les résultats d'appels de fonctions[37].

fn main() {
    // Déclaration de variables
    let mut a = 5; // a est une variable modifiable
    let b = a * 2; // b est non modifiable et du même type que a

    // Constantes
    const c: u32 = 5; // déclaration d'une constante entière non-signée
    const c: u8 = b - 3; // interdit car `b - 3` n'est pas une expression constante (b non défini à la compilation)
    const c = 5; // interdit car le type de c n'est pas précisé

    // Altération
    c = 3; // illégal car c est une constante
    b = 3; // illégal car b est une variable immuable
    a = 2; // autorisé car a est déclaré comme "mut"
    let a = a + 5; // autorisé une nouvelle variable a est créée valant 7,
                   // l'ancienne variable a est "couverte" par la nouvelle (shadowing)

    // Vérification des valeurs
    assert_eq!(a, 5); // faux
    assert_eq!(b, 10); // vrai
}


Énumérations et filtrage par motif[modifier | modifier le code]

Rust permet la définition de types sommes (ou énumérations) à l'aide du mot-clé enum. On peut utiliser ces types sommes avec du filtrage par motif, en utilisant par exemple le mot-clé match.

Exemple :

// On crée un type « Forme » pour décrire des formes géométriques.
enum Forme {
    Point,               // une forme peut être un point, sans données attachées.
    Cercle(f64),         // une forme peut être un cercle, caractérisé par son rayon.
    Rectangle(f64, f64), // une forme peut être un rectangle, caractérisé par les longueurs de deux de ses côtés adjacents.
}

// Calcule l'aire d'une forme géométrique.
fn aire(f: Forme) -> f64 {
    match f {
        // Filtrage par motif avec « match »
        Forme::Point => 0.0,
        Forme::Cercle(rayon) => rayon * rayon * 3.1415926535897932384626433832795,
        Forme::Rectangle(cote_a, cote_b) => cote_a * cote_b,
    }
}

Certaines énumérations font partie de la bibliothèque standard, comme Option, permettant d'éviter l'utilisation du pointeur NULL[38].

Métaprogrammation permise grâce au filtrage par motif[modifier | modifier le code]

Programmation générique[modifier | modifier le code]

Afin de garantir la programmation générique, le langage Rust implémente son propre système de métaprogrammation basé sur les traits. Ainsi, un développeur souhaitant mettre en place une fonction générique sera dans l’obligation d’expliciter les différents traits utilisés dans sa fonction, son objet ou sa méthode.

Exemple de l’implémentation du tri-bulle de manière générique :

fn tri_bulle<T: std::cmp::PartialOrd>(liste: &mut Vec<T>) {
    // Ici, on a besoin de l’opérateur de comparaison < implémenté par le trait
    // PartialOrd
    let mut i = 0;

    while i < (liste.len() - 1) {
        if liste[i] < liste[i + 1] {
            liste.swap(i, i + 1);
            i = 0;
        } else {
            i += 1;
        }
    }
}

Ainsi, toute liste de valeurs prenant en charge l’opérateur de comparaison « < » pourra être passée comme argument pour cette fonction.

Définition des méthodes communes par le biais de traits[modifier | modifier le code]

Les traits sont assimilables aux interfaces en java ou aux classes abstraites en C++ : Ils définissent les méthodes qui seront proposées par les structures les implémentant. Ils sont des composants centraux du langage, étant donné que les opérations comme les additions sont définies via l’implémentation de traits. Ces derniers peuvent également proposer une implémentation générique de certaines de leur fonctions à condition que ces dernières ne requièrent pas l’utilisation de données stockées dans les objets.

Exemple de définition d‘un trait :

trait Polygone {
    fn nombre_cotes(&self) -> usize;

    fn points(&self) -> Vec<(f32, f32)>;

    // Il n’existe pas de méthode simple et générique pour calculer l’aire d’un
    // polygone
    fn aire(&self) -> f32;

    fn perimetre(&self) -> f32 {
        let mut ret = 0.0;
        let points = self.points();

        for i in 1..points.len() {
            ret += f32::sqrt(
                f32::pow(points[i].0 - points[i - 1].0, 2)
                    + f32::pow(points[i].1 - points[i - 1].1, 2),
            );
        }

        return ret;
    }
}

Possession et emprunt[modifier | modifier le code]

Pour obtenir des garanties de sûreté, Rust utilise les concepts d'ownership (propriété ou possession) et de borrowing (emprunt).

Ainsi, une valeur a toujours un seul propriétaire. Si la valeur change de propriétaire, l'ancien propriétaire ne peut plus l'utiliser.

Par exemple :

fn prend_possession(v: Vec<i32>) {
    // Cette fonction prend possession de son paramètre v et ne la rend pas.
    println!("{:?}", v);
}

fn main() {
    let mut a = vec![1, 2, 3]; // a est le propriétaire du vecteur.
    let mut b = a; // b est maintenant le propriétaire du vecteur.

    // pas clair,
    a.push(4); // erreur de compilation : a n'a plus le droit d'utiliser ce vecteur

    prend_possession(b);
    b.push(5); // erreur de compilation : b n'a plus le droit d'utiliser ce vecteur
}

Pour utiliser une valeur à plusieurs endroits à la fois, il est possible de prêter cette valeur en créant des références.

Il est possible de créer :

  • Soit des références immuables, avec l'opérateur &.
  • Soit une référence muable, avec l'opérateur & mut.

En particulier, il n'est pas possible de mélanger les références muables et immuables.

Exemple :

fn take_reference(v: &Vec<i32>) {
    // Cette fonction prend une référence vers un vecteur
    println!("{:?}", v);
}

fn correct() {
    let a = vec![1, 2, 3];
    let ref_1 = &a;
    let ref_2 = &a;
    // On crée plusieurs références immuables vers a que l'on peut passer à des fonctions.
    // Faire ceci ne serait pas possible si l'on travaillait avec une fonction qui prend
    // l'ownership de a.
    take_reference(ref_1);
    take_reference(ref_2);
}

fn incorrect() {
    let mut a = vec![1, 2, 3];
    // Ce code ne compile pas.
    // En effet, on travaille à la fois avec une référence muable vers a (ref_1),
    // et à la fois avec une référence immuable vers a (ref_2).
    let ref_1 = &mut a[0];
    let ref_2 = &a;
    println!("{}", *ref_1);
    take_reference(ref_2);
}

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[39][réf. obsolète][40]. Ces concepts ont été empruntés à des langages de programmation existants et assemblés dans un seul langage[41] :

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

Composants[modifier | modifier le code]

Compilation d'un programme Rust avec Cargo

L'écosystème Rust comprend son compilateur, sa bibliothèque standard, et des composants supplémentaires pour le développement de logiciels. L'installation des composants est généralement gérée par rustup, un installateur de chaîne de compilation Rust développé par le projet Rust[43].

Compilateur[modifier | modifier le code]

Le compilateur Rust est nommé rustc. En interne, rustc est un frontal pour divers moteurs qui sont utilisés pour obtenir des fichiers de code binaire spécifiques aux appareils et aux plates-formes (par exemple, ELF ou WASM binaire). Le moteur le plus mature et le plus utilisé dans rustc est le compilateur de représentation intermédiaire (bytecode) LLVM,

Bibliothèque standard[modifier | modifier le code]

La bibliothèque standard de Rust définit et implémente les types de données personnalisés les plus utilisés, y compris les structures de données de base telles que Vec, Option, et HashMap, ainsi que les types pointeurs intelligents. Rust fournit également un moyen d'exclure la plupart de la bibliothèque standard en utilisant l'attribut #![no_std] ; cela permet aux applications, telles que les dispositifs embarqués, qui veulent supprimer le code de dépendance ou fournir leurs propres structures de données de base. En interne, la bibliothèque standard est divisée en trois parties, core, alloc et std, où std et alloc sont exclus par #![no_std].[44]

Capture d'écran de crates.io en juin 2022

Cargo[modifier | modifier le code]

Cargo est le moteur de production et le gestionnaire de paquets de Rust. Il télécharge, compile, distribue et met en ligne des paquets - appelés "crates" - qui sont maintenus dans un registre officiel. Il agit également comme une interface pour Clippy et d'autres composants Rust[12].

Par défaut, Cargo puise ses dépendances dans le registre crates.io alimenté par les utilisateurs, mais les dépôts Git et les crates dans le système de fichiers local, ainsi que d'autres sources externes, peuvent également être spécifiés comme dépendances[45].

Rustfmt[modifier | modifier le code]

Rustfmt est un formateur de code pour Rust. Il formate les espaces blancs et indentation pour produire du code en accord avec un style commun, sauf indication contraire. Il peut être invoqué en tant que programme autonome, ou à partir d'un projet Rust via Cargo.[46]

Exemple de sortie de Clippy sur un programme Rust hello world

Clippy[modifier | modifier le code]

Clippy est l'outil de lint intégré à la chaîne de compilation Rust pour améliorer la correction, les performances et la lisibilité du code Rust. Il a été créé en 2014[47] et nommé d'après l'Assistant de Microsoft Office, un trombone anthropomorphisé du même nom[48]. Fin 2023, il compte plus de 650 règles[49],[50], qui peuvent être parcourues en ligne et filtrées par catégorie[51].

Environnement de développement[modifier | modifier le code]

Le serveur de langage (en) le plus populaire pour Rust est Rust Analyzer, qui a officiellement remplacé le serveur de langue original, RLS, en juillet 2022[52]. Rust Analyzer fournit aux environnement de développement intégrés et aux éditeurs de textes des informations sur un projet Rust ; des fonctionnalités de base incluant autocomplétion, et l'affichage des erreurs de compilation pendant l'édition. [53]

Performance[modifier | modifier le code]

En général, les garanties de sécurité mémoire de Rust n'imposent pas de surcharge à l'exécution[54]. Une exception notable est indexation de tableau qui est vérifiée à l'exécution, bien que cela n'ait souvent pas d'impact sur les performances[55]. Dans la mesure où il ne dispose pas de ramasse-miettes, Rust est souvent plus rapide que d'autres langages à sécurité mémoire[56],[57],[58].

Rust dispose deux "modes" coexistant : safe et unsafe. Le mode safe est le mode "normal", dans lequel la plupart des codes Rust sont écrits. En mode unsafe, le développeur est responsable de la sécurité mémoire du code, ce qui est utile dans les cas où le compilateur est trop restrictif[59].

De nombreuses fonctionnalités de Rust sont des abstractions dites "à coût zéro", ce qui signifie qu'elles sont optimisées à la compilation et n'entraînent aucune pénalité à l'exécution[60]. Le système de propriété et d'emprunt permet des implémentations zéro coût (en) pour certaines tâches sensibles aux performances, telles que parsing[61]. Le dispatch statique est utilisé par défaut pour éliminer les appel de méthodes, à l'exception des méthodes appelées sur des objets traits dynamiques[62]. Le compilateur utilise également l'extension inline pour éliminer les appels de fonctions et les invocations de méthodes distribuées statiquement[63].

Puisque Rust utilise LLVM, toutes les améliorations de performance dans LLVM sont également transférées au compilateur Rust[64]. Contrairement aux C et C++, Rust permet de réordonner les éléments struct et enum[65] pour réduire la taille des structures en mémoire, pour un meilleur alignement de la mémoire et pour améliorer l'efficacité de l'accès au cache[66].

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

Exemples de code[modifier | modifier le code]

Hello world :

// This is the main function
fn main() {
    // The statements here will be executed when the compiled binary is called

    // Print text to the console
    println!("Hello World!");
}

Arrays and Slices :

use std::mem;

// This function borrows a slice
fn analyze_slice(slice: &[i32]) {
    println!("first element of the slice: {}", slice[0]);
    println!("the slice has {} elements", slice.len());
}

fn main() {
    // Fixed-size array (type signature is superfluous)
    let xs: [i32; 5] = [1, 2, 3, 4, 5];

    // All elements can be initialized to the same value
    let ys: [i32; 500] = [0; 500];

    // Indexing starts at 0
    println!("first element of the array: {}", xs[0]);
    println!("second element of the array: {}", xs[1]);

    // `len` returns the size of the array
    println!("array size: {}", xs.len());

    // Arrays are stack allocated
    println!("array occupies {} bytes", mem::size_of_val(&xs));

    // Arrays can be automatically borrowed as slices
    println!("borrow the whole array as a slice");
    analyze_slice(&xs);

    // Slices can point to a section of an array
    println!("borrow a section of the array as a slice");
    analyze_slice(&ys[1..4]);

    // Out of bound indexing yields a panic
    println!("{}", xs[5]);
}

Bibliographie[modifier | modifier le code]

  • Jim Blandy et Jason Orendorff, Programmer avec Rust - pour une programmation système rapide et sûre, First Interactive, 5 septembre 2019, (ISBN 9782412046593)
  • Benoît Prieur, Rust - Développez des programmes robustes et sécurisés, Éditions ENI, , 362 p. (ISBN 2-409-03528-0)Voir et modifier les données sur Wikidata
  • (en) Jon Gjengset, Rust for Rustaceans, No Starch Press, , 1st éd. (ISBN 9781718501850, OCLC 1277511986, lire en ligne)
  • (en) Steve Klabnik et Carol Nichols, The Rust Programming Language (Covers Rust 2018), No Starch Press, (ISBN 978-1-7185-0044-0, lire en ligne)

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

  1. a et b (en) « Announcing Rust 1.76.0 », (consulté le )
  2. (en) « The Rust Reference », sur rust-lang.org (consulté le ).
  3. « Chris Lattner's Homepage », sur nondot.org (consulté le ).
  4. (en) « V documentation (Introduction) », sur GitHub (consulté le ).
  5. (en) Serdar Yegulalp, « New challenger joins Rust to topple C language », sur InfoWorld, (consulté le ).
  6. a et b GitHub, (service Internet)Voir et modifier les données sur Wikidata
  7. a et b « https://github.com/rust-lang/rust/blob/master/COPYRIGHT »
  8. (en) Prabhu Eshwarla, Practical System Programming for Rust Developers: Build fast and secure software for Linux/Unix systems with the help of practical examples, Packt Publishing Ltd, (ISBN 978-1-80056-201-1, lire en ligne)
  9. (en) Jim Blandy et Jason Orendorff, Programming Rust: Fast, Safe Systems Development, O'Reilly Media, Inc., (ISBN 978-1-4919-2725-0, lire en ligne)
  10. (en) Sergi Blanco-Cuaresma et Emeline Bolmont, « What can the programming language Rust do for astrophysics? », Proceedings of the International Astronomical Union, vol. 12, no S325,‎ , p. 341–344 (ISSN 1743-9213, DOI 10.1017/S1743921316013168, Bibcode 2017IAUS..325..341B, arXiv 1702.02951, S2CID 7857871, lire en ligne)
  11. (en) Michael Larabel, « The Initial Rust Infrastructure Has Been Merged Into Linux 6.1 », sur phoronix.com, .
  12. a et b (en) Jeffrey M. Perkel, « Why scientists are turning to Rust », Nature, vol. 588, no 7836,‎ , p. 185–186 (PMID 33262490, DOI 10.1038/d41586-020-03382-2, Bibcode 2020Natur.588..185P, S2CID 227251258, lire en ligne [archive du ], consulté le )
  13. (en) « Computer Scientist proves safety claims of the programming language Rust » [archive du ], sur EurekAlert! (consulté le ).
  14. Ralf Jung, Jacques-Henri Jourdan, Robbert Krebbers et Derek Dreyer, « RustBelt: securing the foundations of the Rust programming language », Proceedings of the ACM on Programming Languages, vol. 2, no POPL,‎ , p. 66:1–66:34 (DOI 10.1145/3158154, S2CID 215791659, lire en ligne [archive du ], consulté le )
  15. (en) Ralf Jung, Understanding and evolving the Rust programming language (thèse), Université de la Sarre, (DOI 10.22028/D291-31946, lire en ligne [archive du ])
  16. a et b (en) Clive Thompson, « How Rust went from a side project to the world's most-loved programming language », sur MIT Technology Review, (consulté le ).
  17. a et b (en) Abel Avram, « Interview on Rust, a Systems Programming Language Developed by Mozilla » [archive du ], InfoQ, (consulté le ).
  18. (en-US) Matt Asay, « Rust, not Firefox, is Mozilla's greatest industry contribution », sur TechRepublic, (consulté le ).
  19. (en) Graydon Hoare « Project Servo » () (lire en ligne, consulté le ) [archive du ]
    Mozilla Annual Summit 2010
  20. (en) Graydon Hoare, « [rust-dev] Rust 0.2 released », sur mail.mozilla. org, (consulté le ).
  21. (en) Graydon Hoare, « [rust-dev] Rust 0.3 released » [org/web/20220824145952/https://mail.mozilla.org/pipermail/rust-dev/2012-July/002087.html archive du ], sur mail.mozilla.org, (consulté le ).
  22. (en) Graydon Hoare, « [rust-dev] Rust 0.4 released » [archive du ], sur mail.mozilla.org, (consulté le ).
  23. (en) Andrew Binstock, « The Rise And Fall of Languages in 2013 », Dr. Dobb's Journal,‎ (lire en ligne [archive du ], consulté le )
  24. (en) « Version History » [archive du ], sur GitHub] (consulté le ).
  25. (en) The Rust Core Team, « Announcing Rust 1.0 » [archive du ], sur Rust Blog, (consulté le ).
  26. (en-US) Frederic Lardinois, « It's time to give Firefox another chance », sur TechCrunch, (consulté le ).
  27. (en) Catalin Cimpanu, « Mozilla licencie 250 employés tout en se recentrant sur les produits commerciaux » [archive du ], ZDNet, (consulté le ).
  28. (en) Daniel Cooper, « Mozilla licencie 250 employés en raison de la pandémie » [archive du ], sur Engadget), (consulté le ).
  29. (en) Liam Tung, « Langage de programmation Rust : Mozilla job cuts have hit badly but here's how we'll survive » [archive du ], ZDNet (consulté le ).
  30. (en) « Laying the foundation for Rust's future » [archive du ], sur Rust Blog, (consulté le ).
  31. (en) « Hello World ! » [archive du ], sur Rust Foundation, (consulté le ).
  32. (en) « Mozilla Welcomes the Rust Foundation » [org/blog/2021/02/08/mozilla-welcomes-the-rust-foundation/ archive du ], sur Mozilla Blog, (consulté le ).
  33. (en) Ron Amadeo, « Google is now writing low-level Android code in Rust » [archive du ], sur Ars Technica, (consulté le ).
  34. (en) Tim Anderson, « Entire Rust moderation team resigns », sur The Register], (consulté le ).
  35. (en) « Governance Update », sur Inside Rust Blog (consulté le ).
  36. (en) Thomas Claburn, « Rust Foundation apologizes for trademark policy confusion », sur The Register, (consulté le ).
  37. « Variables and Mutability - The Rust Programming Language », sur doc.rust-lang.org (consulté le ).
  38. (en) « The Rust Programming Language », sur rust-lang.org (consulté le ).
  39. « Présentation de Rust sur Léa-Linux » (consulté le ).
  40. (en) Nicholas Matsakis et Aaron Turon, « Préambule » (consulté le ).
  41. « Sortie de Rust 0.8 » (consulté le ).
  42. Vincent Hermann, « Microsoft se penche sur le langage Rust pour sa programmation système » (consulté le ).
  43. (ja) 秀人 樽井, « 「Rust」言語のインストーラー「Rustup」が「Visual Studio 2022」の自動導入に対応/Windows/Mac/Linux、どのプラットフォームでも共通の手順でお手軽セットアップ », sur 窓の杜,‎ (consulté le ).
  44. Gjengset 2021, p. 213-215.
  45. (en) Sergio De Simone, « Rust 1.34 Introduits Alternative Registries for Non-Public Crates », sur InfoQ, (consulté le ).
  46. Klabnik et Nichols 2019, p. 511-512.
  47. (en) « Créer README.md - rust-lang/rust-clippy@507dc2b » [com/rust-lang/rust-clippy/commit/507dc2b7ec30cf94554b441d4fcb1ce113f98a16 archive du ], sur GitHub (consulté le ).
  48. (en) « 24 days of Rust : Day 1 : Cargo subcommands » [archive du ], sur zsiciarz.github.io (consulté le ).
  49. (en) « Clippy », The Rust Programming Language, (consulté le ).
  50. (en) « Clippy Lints », sur rust-lang.github.io (consulté le ).
  51. (en) « ALL the Clippy Lints » [archive du ] (consulté le ).
  52. (en-GB) Tim Anderson, « Rust team releases 1.62, sets end date for deprecated language server », sur DEVCLASS, (consulté le ).
  53. Klabnik et Nichols 2023, p. 623.
  54. McNamara 2021, p. 11.
  55. (en) Natalie Popescu, Ziyang Xu, Sotiris Apostolakis, David I. August et Amit Levy, « Safer at any speed : automatic context-aware safety enhancement for Rust », Proceedings of the ACM on Programming Languages, vol. 5, no OOPSLA,‎ , Section 2 (DOI 10.1145/3485480, S2CID 238212612, lire en ligne) :

    « "Nous observons une grande variance dans les frais généraux de l'indexation vérifiée : 23. 6% des benchmarks rapportent des performances significatives dues à l'indexation vérifiée, mais 64,5% rapportent peu ou pas d'impact et, de manière surprenante, 11,8% rapportent des performances améliorées... En fin de compte, si l'indexation non vérifiée peut améliorer les performances, la plupart du temps, elle ne le fait pas." »

  56. (en) Tim Anderson, « Can Rust save the planet? Why, and why not », sur The Register (consulté le ).
  57. (en) Abhiram Balasubramanian, Marek S. Baranowski, Anton Burtsev, Aurojit Panda, Zvonimir Rakamarić et Leonid Ryzhyk, Proceedings of the 16th Workshop on Hot Topics in Operating Systems, Whistler BC Canada, ACM, , 156–161 p. (ISBN 978-1-4503-5068-6, DOI 10.1145/3102980.3103006, S2CID 24100599), « System Programming in Rust »
  58. (en) Serdar Yegulalp, « What is the Rust language? Safe, fast, and easy software development », sur InfoWorld, (consulté le ).
  59. (en) Krzysztof Wróbel, « Rust projects - why large IT companies use Rust ? » [archive du ], .
  60. McNamara 2021, p. 19, 27.
  61. (en) Geoffroy Couprie, 2015 IEEE Security and Privacy Workshops, , 142-148 p. (ISBN 978-1-4799-9933-0, DOI 10.1109/SPW.2015 .31, S2CID 16608844), « Nom, A Byte oriented, streaming, Zero copy, Parser Combinators Library in Rust »
  62. McNamara 2021, p. 20.
  63. (en) « Code generation - The Rust Reference », sur doc.rust-lang.org (consulté le ).
  64. (en) « How Fast Is Rust ? » [? archive du ], sur La FAQ du langage de programmation Rust (consulté le ).
  65. (en) Alireza Farshin, Tom Barbette, Amir Roozbeh, Gerald Q. Maguire Jr et Dejan Kostić, Proceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, , 1-17 p. (ISBN 9781450383172, DOI 10.1145/3445814.3446724, S2CID 231949599, lire en ligne), « PacketMill : Toward per-Core 100-GBPS networking » :

    « .... Alors que certains compilateurs (par exemple, Rust) prennent en charge la réorganisation des structures [82], les compilateurs C et C++ n'ont pas le droit de réorganiser les structures de données (par exemple, struct ou class) [74] ... »

  66. (en) « Type layout », sur The Rust Reference (consulté le ).
  67. « Shipping Rust in Firefox ★ Mozilla Hacks – the Web developer blog », sur hacks.mozilla.org (consulté le ).
  68. « Why Discord is switching from Go to Rust », sur blog.discordapp.com (consulté le ).
  69. (en-US) Boyd Johnson, « Safety, Performance and Innovation: Rust in Hyperledger Sawtooth », (consulté le ).
  70. (en-US) Cade Metz, « The Epic Story of Dropbox’s Exodus From the Amazon Cloud Empire », WIRED,‎ (lire en ligne, consulté le )
  71. (en) « Rust support moves into Android underpinnings », sur ZDNet (consulté le ).

Articles connexes[modifier | modifier le code]

Liens externes[modifier | modifier le code]