Rust 1.59.0 est disponible. Cette version désactive par défaut la compilation incrémentielle,
et autorise la création de binaires dépouillés

L'équipe Rust a publié une nouvelle version de Rust, 1.59.0.

Rust est un langage de programmation compilé multi-paradigme conçu et développé par Mozilla Research depuis 2010. Il a été conçu pour être « un langage fiable, concurrent, pratique », supportant les styles de programmation purement fonctionnel, modèle d'acteur (il s'agit d'un modèle de programmation concurrente, dans lequel la charge de travail est répartie entre des entités s'exécutant en parallèle, les acteurs. C'est un modèle dans lequel il n'y a pas d'état partagé, les acteurs sont isolés et l'information ne peut circuler que sous forme de messages), procédural, ainsi qu'orienté objet sous certains aspects.

En 2020, ses domaines de prédilection sont la programmation système, les applications en ligne de commande, les applications Web via WebAssembly, les services réseaux et les systèmes embarqués.

Du fait de la politique de Mozilla, 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é.

L'équipe n'a pas manqué d'adressé son soutien au peuple Ukrainien :

« La publication d'aujourd'hui tombe le jour où l'attention du monde est captée par la soudaine invasion de l'Ukraine par les forces de Poutine. Avant d'entrer dans les détails de la nouvelle version de Rust, nous aimerions déclarer que nous sommes solidaires du peuple ukrainien et exprimons notre soutien à toutes les personnes touchées par ce conflit ».

Alors quoi de neuf (ou d'amélioré) dans Rust ?

Assemblage en ligne

Le langage Rust prend désormais en charge l'assemblage en ligne. Cela peut être utile pour de nombreuses applications qui ont besoin d'un contrôle de très bas niveau sur leur exécution ou d'accéder à des instructions machine spécialisées.

Lors de la compilation pour des cibles x86-64, par exemple, vous pouvez désormais écrire :

Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
use std::arch::asm;
 
// Multiply x by 6 using shifts and adds
let mut x: u64 = 4;
unsafe {
    asm!(
        "mov {tmp}, {x}",
        "shl {tmp}, 1",
        "shl {x}, 2",
        "add {x}, {tmp}",
        x = inout(reg) x,
        tmp = out(reg) _,
    );
}
assert_eq!(x, 4 * 6);

La syntaxe de la chaîne de format utilisée pour nommer les registres dans asm! et global_asm!, les macros sont les mêmes que celles utilisées dans les chaînes de format Rust, elles devraient donc sembler assez familières aux développeurs Rust.

Le langage d'assemblage et les instructions disponibles avec l'assemblage en ligne varient en fonction de l'architecture cible. Aujourd'hui, le compilateur stable Rust prend en charge l'assemblage en ligne sur les architectures suivantes :
  • x86 and x86-64
  • ARM
  • AArch64
  • RISC-V

Déstructuration d'une affectation

Vous pouvez désormais utiliser des modèles de tuple, de tranche et de structure comme côté gauche d'une affectation.

Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
let (a, b, c, d, e);
 
(a, b) = (1, 2);
[c, .., d, _] = [1, 2, 3, 4, 5];
Struct { e, .. } = Struct { e: 5, f: 3 };
 
assert_eq!([1, 2, 1, 4, 5], [a, b, c, d, e]);

Cela rend l'affectation plus cohérente avec les liaisons let, qui supportent depuis longtemps la même chose. Notez que les affectations de déstructuration avec des opérateurs tels que += ne sont pas autorisées.

Génériques const par défaut et entrelacement

Les types génériques peuvent désormais spécifier des valeurs par défaut pour leurs génériques const. Par exemple, vous pouvez maintenant écrire ce qui suit*:

Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
struct ArrayStorage<T, const N: usize = 2> {
    arr: [T; N],
}
 
impl<T> ArrayStorage<T> {
    fn new(a: T, b: T) -> ArrayStorage<T> {
        ArrayStorage {
            arr: [a, b],
        }
    }
}

Auparavant, les paramètres de type devaient précéder tous les paramètres const. Cette restriction a été assouplie et vous pouvez maintenant les entrelacer.

Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
fn cartesian_product<
    T, const N: usize,
    U, const M: usize,
    V, F
>(a: [T; N], b: [U; M], f: F) -> [[V; N]; M]
where
    F: FnMut(&T, &U) -> V
{
    // ...
}

Nom : rust.png
Affichages : 5145
Taille : 53,6 Ko

Futurs avertissements d'incompatibilité

Parfois, des bogues dans le compilateur Rust le font accepter du code qui n'aurait pas dû être accepté. Un exemple de ceci était les emprunts de champs de structure compressés autorisés dans le code sécurisé.

Bien que cela se produise très rarement, cela peut être assez perturbant lorsqu'une crate (une crate est un binaire ou une bibliothèque) utilisée par votre projet contient du code qui ne sera plus autorisé. En fait, vous ne le remarquerez peut-être pas tant que votre projet ne s'arrêtera pas inexplicablement pendant les phases de build.

Cargo vous affiche désormais des avertissements lorsqu'une dépendance sera rejetée par une future version de Rust. Après avoir exécuté cargo build ou cargo check, vous pouvez voir :

Citation Envoyé par avertissement
warning: the following packages contain code that will be rejected by a future version of Rust: old_dep v0.1.0
note: to see what the problems were, use the option `--future-incompat-report`, or run `cargo report future-incompatibilities --id 1`
Vous pouvez exécuter cargo report mentionnée dans l'avertissement pour voir un rapport complet du code qui sera rejeté. Cela vous donne le temps de mettre à niveau votre dépendance avant qu'elle ne casse votre build.

Création de binaires dépouillés

Il est souvent utile de supprimer les informations inutiles telles que les informations de débogage des fichiers binaires que vous distribuez, en les rendant plus petits.

Bien qu'il ait toujours été possible de le faire manuellement après la création du binaire, cargo et rustc prennent désormais en charge la suppression lorsque le binaire est lié. Pour activer cela, ajoutez ce qui suit à votre Cargo.toml :

Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
[profile.release]
strip = "debuginfo"

Cela entraîne la suppression de debuginfo des fichiers binaires de version. Vous pouvez également fournir des "symbols" ou simplement true pour supprimer toutes les informations de symbole lorsqu'elles sont prises en charge.

La bibliothèque standard est généralement livrée avec des symboles de débogage et des informations de débogage au niveau de la ligne, de sorte que les binaires Rust construits sans symboles de débogage activés incluent toujours les informations de débogage de la bibliothèque standard par défaut. L'utilisation de l'option strip vous permet de supprimer ces informations supplémentaires, produisant des fichiers binaires Rust plus petits.

Compilation incrémentielle désactivée par défaut

La version 1.59.0 désactive l'incrémentation par défaut (sauf demande explicite via une variable d'environnement : RUSTC_FORCE_INCREMENTAL=1). Cela atténue les effets d'un bogue connu, #94124, qui peut provoquer des erreurs de désérialisation (et des paniques) lors de la compilation avec la compilation incrémentielle activée.

Le correctif spécifique pour #94124 est disponible et est actuellement dans la version bêta 1.60, qui sera livrée dans six semaines. L'équipe indique ne pas être actuellement au courant d'autres problèmes qui encourageraient une décision de désactiver la compilation incrémentielle dans la version 1.60 stable, et si aucun ne se pose, il est probable que la version 1.60 stable réactive la compilation incrémentielle. La compilation incrémentielle reste activée par défaut dans les chaînes bêta et nightly.

API stabilisées

Les méthodes et implémentations de traits suivantes sont désormais stabilisées :
  • std::thread::available_parallelism
  • Result::copied
  • Result::cloned
  • arch::asm!
  • arch::global_asm!
  • ops::ControlFlow::is_break
  • ops::ControlFlow::is_continue
  • TryFrom<char> for u8
  • char::TryFromCharError implementing Clone, Debug, Display, PartialEq, Copy, Eq, Error
  • iter::zip
  • NonZeroU8::is_power_of_two
  • NonZeroU16::is_power_of_two
  • NonZeroU32::is_power_of_two
  • NonZeroU64::is_power_of_two
  • NonZeroU128::is_power_of_two
  • DoubleEndedIterator for ToLowercase
  • DoubleEndedIterator for ToUppercase
  • TryFrom<&mut [T]> for [T; N]
  • UnwindSafe for Once
  • RefUnwindSafe for Once
  • armv8 neon intrinsics for aarch64

Rust, un langage apprécié par les développeurs

Plus tôt ce mois-ci, l'équipe Rust a publié les résultats de l'édition 2021 de l'enquête sur l'écosystème Rust (Rust Survey).

L'enquête, menée en décembre et qui a interrogé 9354 personnes dans 113 pays et territoires différents, a révélé que l'utilisation de Rust en production a progressé, mais de nombreux défis restent à relever pour améliorer le langage. Parmi les personnes interrogées, elles sont 81% à l’utiliser au moins une fois par semaine (contre 72% dans la même enquête l’année dernière). Sur les plus de 9 300 répondants, 75% ont déclaré être en mesure d’écrire du code prêt pour la production, mais 27% ont rencontré des difficultés.

La communauté des développeurs Rust estime que l’adoption du langage au démarrage est un défi (83%). L’étude s’interroge néanmoins sur ce chiffre. Il est toutefois difficile de savoir dans quelle mesure ce constat est lié à Rust lui-même ou aux difficultés générales liées à l'adoption d'un nouveau langage de programmation. Par contre, une fois acquis, 82% ont trouvé que Rust aidait leurs équipes à atteindre leurs objectifs. Interrogés sur les raisons de l’adoption de Rust, les développeurs estiment que le langage leur permet de « construire des logiciels relativement corrects et sans bogues ».

Selon le rapport, les autres domaines nécessitant des améliorations sont l'espace disque (45 %), le débogage (40 %) et le développement d'interfaces graphiques (56 %). Il ajoute également que l'expérience de l'EDI (grâce à l'adoption et à l'amélioration constantes de divers outils tels que "rust-analyzer", IntelliJ Rust, etc.) est celle qui s'est le plus améliorée : 56 % des répondants estiment qu'elle s'est améliorée au cours de l'année écoulée.

Mais l’appropriation de Rust reste un défi et les utilisateurs souhaitent des améliorations sur certains points. Par exemple, ils sont 61% à juger qu’il y a des progrès à faire dans le temps de compilation. Un pourcentage à mettre en perspective avec les 61% aussi qui estiment que des améliorations ont été réalisées dans ce domaine. Les autres domaines nécessitant des améliorations sont l'espace disque occupé (45 %), le débogage (40 %) et le développement d'interfaces graphiques (56 %).

Parmi les autres inquiétudes, les utilisateurs de Rust sont 33% à craindre que le langage devienne trop complexe. Par ailleurs, les développeurs travaillant sur Rust appréhendent de ne pas trouver le soutien approprié dont ils ont besoin pour continuer à développer le langage et la communauté (30%).

Source : Rust

Voir aussi :

Rust peut-il sauver la planète ? Un composant JavaScript a été réécrit en Rust et aurait une amélioration de 50 % de la latence, une réduction de 75 % de l'utilisation du CPU et 95 % de la mémoire
Au moins 59 % des développeurs Rust l'utilisent occasionnellement au travail et 23 % l'utilisent pour la majorité de leur codage, selon une enquête sur l'écosystème du langage
Rust 1.58 est disponible avec la réduction du chemin de recherche sous Windows et étend les chaînes de format, ainsi que l'utilisation de #[must_use] dans la bibliothèque standard
« Choisir Rust est opter pour une meilleure sécurisation des logiciels qu'avec le C, mais une efficacité énergétique et une performance d'exécution que seul le C offre », d'après l'équipe AWS