La version 1.95 du langage de programmation Rust, initialement développé par Mozilla, est désormais maintenue par la Rust Foundation, une organisation indépendante et à but non lucratif. Le langage se concentre sur la gestion sécurisée de la mémoire et fournit des outils pour atteindre un haut niveau de parallélisme dans l'exécution des tâches, tout en évitant l'utilisation d'un ramasse-miettes et d'un runtime (le runtime se limite à l'initialisation de base et à l'accompagnement de la bibliothèque standard).
Les méthodes de gestion de la mémoire dans Rust visent à éliminer les erreurs lors de la manipulation des pointeurs et à protéger contre les problèmes liés à une gestion de la mémoire à bas niveau, tels que l'accès à une zone mémoire après sa libération, la déréférence de pointeurs nuls, les débordements de tampon, etc. Pour la distribution de bibliothèques, la construction et la gestion des dépendances, un gestionnaire de paquets nommé Cargo est développé. Un dépôt crates.io est maintenu pour l'hébergement des bibliothèques.
La sécurité de la mémoire dans Rust est assurée au moment de la compilation grâce à la vérification des références, au suivi de la propriété des objets, à la prise en compte de la durée de vie des objets (portée) et à l'évaluation de l'accès mémoire pendant l'exécution du code. Rust offre également des outils pour se protéger contre les débordements d'entiers, exige l'initialisation obligatoire des valeurs des variables avant leur utilisation, gère mieux les erreurs dans la bibliothèque standard, applique le concept d'immuabilité (immutable) pour les références et les variables par défaut, et propose une forte typage statique pour minimiser les erreurs logiques.
Les principales nouveautés :
- Le macro « cfg_select! » a été ajouté, pouvant être utilisé à la place du paquet « cfg-if » pour traiter plusieurs conditions de compilation dans le style d'un bloc « match », sans avoir à définir une chaîne d'expressions conditionnelles avec la construction « #[cfg] ». cfg_select! { unix => { fn foo() { /* unix */ } } target_pointer_width = «32» => { fn foo() { /* pas-unix, 32-bit */ } } _ => { fn foo() { /* pas unix et pas 32-bit */ } } }
- La possibilité d'utiliser des expressions « if let » à l'intérieur des blocs « match » pour créer des correspondances conditionnelles par motif a été stabilisée. Auparavant, le soutien pour l'utilisation de plusieurs expressions « let » avec l'opérateur « && » avait été stabilisé pour les blocs « if » et « while ». match value { Some(x) if let Ok(y) = compute(x) => { println!(«{}, {}», x, y); } _ => {} }
- Le support de l'assembleur en ligne pour les architectures PowerPC et PowerPC64 a été stabilisé.
- Une nouvelle série d'API a été stabilisée dans la catégorie des API stables, notamment des méthodes et des implémentations de traits stabilisées :
- MaybeUninit<[T; N]>: From<[MaybeUninit<T>; N]>
- MaybeUninit<[T; N]>: AsRef<[MaybeUninit<T>; N]>
- MaybeUninit<[T; N]>: AsRef<[MaybeUninit<T>]>
- MaybeUninit<[T; N]>: AsMut<[MaybeUninit<T>; N]>
- MaybeUninit<[T; N]>: AsMut<[MaybeUninit<T>]>
- [MaybeUninit<T>; N]: From<MaybeUninit<[T; N]>
- Cell<[T; N]>: AsRef<[Cell<T>; N]>
- Cell<[T; N]>: AsRef<[Cell<T>]>
- Cell<[T]>: AsRef<[Cell<T>]>
- bool: TryFrom<{integer}>
- AtomicPtr::update
- AtomicPtr::try_update
- AtomicBool::update
- AtomicBool::try_update
- AtomicIn::update
- AtomicIn::try_update
- AtomicUn::update
- AtomicUn::try_update
- cfg_select!
- mod core::range
- core::range::RangeInclusive
- core::range::RangeInclusiveIter
- core::hint::cold_path
- <*const T>::as_ref_unchecked
- <*mut T>::as_ref_unchecked
- <*mut T>::as_mut_unchecked
- Vec::push_mut
- Vec::insert_mut
- VecDeque::push_front_mut
- VecDeque::push_back_mut
- VecDeque::insert_mut
- LinkedList::push_front_mut
- LinkedList::push_back_mut
- Layout::dangling_ptr
- Layout::repeat
- Layout::repeat_packed
- Layout::extend_packed
- L'attribut «const» est appliqué dans les fonctions :
- fmt::from_fn
- ControlFlow::is_break
- ControlFlow::is_continue
- Le support de la transmission des spécifications des plateformes cibles personnalisées au compilateur a été supprimé dans les versions stables de l'outil.
- Les plateformes cibles powerpc64-unknown-linux-musl, aarch64-apple-tvos, aarch64-apple-tvos-sim, aarch64-apple-watchos, aarch64-apple-watchos-sim, aarch64-apple-visionos et aarch64-apple-visionos-sim ont été élevées au second niveau de support, ce qui implique une garantie de construction, mais sans garantie lors du passage de l'ensemble de tests.
De plus, on peut noter les projets et événements récemment annoncés liés à Rust :
- La société Canonical a présenté le serveur d'affichage Mir 2.26, qui offre un ensemble de bibliothèques pour créer des fonctionnalités composites serveurs basé sur le protocole Wayland et incluant la fonctionnalité standard des gestionnaires de fenêtres et des serveurs d'affichage. Mir est utilisé dans des projets tels que le gestionnaire de composite Miracle, l'interface pour les kiosques Internet Ubuntu Frame et l'environnement utilisateur Miriway.
La nouvelle version se distingue par l'ajout de la possibilité de développer des composants en Rust. Une sous-système d'entrée alternative basé sur Rust, evdev-rs, a été mise en œuvre, et le travail a commencé sur le frontend wayland-rs écrit en Rust pour Wayland. Parmi les changements non liés à Rust dans Mir, on note le support des protocoles Wayland ext_image_copy_capture_v1 et input-triggers.
- La première version de l'analyseur de trafic ayaFlow, écrit en Rust et utilisant le sous-système eBPF du noyau Linux pour intercepter des paquets réseau (IPv4/TCP/UDP) et des trames Ethernet avec un impact minimal sur les performances, a été publiée. L'analyseur prend en charge l'inspection approfondie des protocoles de niveau application (L7), tels que l'extraction de TLS SNI et des requêtes DNS lors de l'analyse du trafic chiffré. Le système prend en charge la tenue d'une table avec l'état actuel des connexions au format DashMap, la sauvegarde de l'historique dans SQLite et la restitution des statistiques via une API REST pour Prometheus.
- La possibilité de créer des applications multithreading en Rust, utilisant les fonctionnalités std::thread et s'exécutant côté GPU, a été mise en œuvre.
Source : opennet.ru
