È stata pubblicata la versione 1.84 del linguaggio di programmazione di uso generale Rust, sviluppato inizialmente da Mozilla e ora sostenuto dalla fondazione indipendente Rust Foundation. Il linguaggio si concentra sull'uso sicuro della memoria e fornisce strumenti per raggiungere un alto parallelismo nell'esecuzione dei compiti, senza fare uso di garbage collector e runtime (che si limita alla base inizializzazione e alla gestione della libreria standard).
I metodi di gestione della memoria in Rust liberano gli sviluppatori dagli errori di manipolazione dei puntatori e li proteggono da problemi derivanti da operazioni a basso livello con la memoria, come l'accesso a aree di memoria dopo il loro rilascio, la dereferenziazione di puntatori nulli, l'uscita dai limiti del buffer, ecc. Per la distribuzione delle librerie, l'assicurazione della compilazione e la gestione delle dipendenze, il progetto promuove il gestore di pacchetti Cargo. È supportato un repository per l'hosting delle librerie su crates.io.
La gestione sicura della memoria in Rust è garantita durante la compilazione attraverso il controllo dei riferimenti, il tracciamento della proprietà degli oggetti, la considerazione del tempo di vita degli oggetti (ambiti di visibilità) e la valutazione della correttezza dell'accesso alla memoria durante l'esecuzione del codice. Rust fornisce anche strumenti per proteggere da overflow interi, richiede l'inizializzazione obbligatoria delle variabili prima dell'uso, gestisce meglio gli errori nella libreria standard, applica il concetto di riferimenti e variabili immutabili per impostazione predefinita e offre una forte tipizzazione statica per minimizzare gli errori logici.
Novità principali:
- Nel gestore di pacchetti Cargo è stato stabilizzato un meccanismo di gestione delle dipendenze che seleziona le versioni dei componenti dipendenti tenendo conto della compatibilità con le versioni del compilatore Rust dichiarate come minimamente supportate dal progetto (MSRV, Minimum Supported Rust Version). Questa nuova funzionalità consente ai manutentori di evitare la necessità di selezionare manualmente le vecchie versioni di ciascuna dipendenza in progetti che mantengono la compatibilità con le versioni precedenti degli strumenti Rust. La nuova modalità di risoluzione delle dipendenze sarà attivata di default nella versione Rust 1.85, mentre al momento è disponibile come opzione, da attivare nella sezione «[resolver]» del file «.cargo/config.toml», indicando ‘incompatible-rust-versions = «fallback»’.
- È iniziata la transizione del compilatore a un nuovo gestore di tipi (trait solver), progettato per verificare i confini di applicabilità dei trait, normalizzare i tipi e valutare la compatibilità dei tipi. Nella versione 1.84, il nuovo gestore è stato utilizzato per controllare la coerenza delle implementazioni dei trait, cioè per valutare l'esistenza di non più di un trait per il tipo in esame, tenendo conto del codice proveniente da altri pacchetti crate. Questa verifica ha permesso di eliminare problemi della vecchia implementazione del gestore di tipi, che potrebbero portare a conflitti a causa della sovrapposizione tra diverse implementazioni di trait.
- È stato proposto un nuovo API "Strict Provenance", che può essere utilizzato per convertire un puntatore in un intero e viceversa, tenendo conto dei metadati allegati al puntatore con informazioni sulla sua provenienza e area di utilizzo (oltre all'indirizzo del puntatore, viene allegato un valore "provenance" con informazioni sui collegamenti con altri puntatori, consentendo di determinare dove e quando un puntatore può accedere alla memoria). La conversione di un puntatore in un intero e viceversa può portare a comportamenti indefiniti a causa della difficoltà di tracciare l'origine del puntatore risultante. Il nuovo API consente di eseguire operazioni a basso livello sui puntatori, come salvare informazioni aggiuntive nei bit inferiori del puntatore, senza convertire il puntatore in un intero.
- Una nuova serie di API è stata trasformata in versioni stabili, inclusi i metodi stabilizzati e le implementazioni delle trait:
- Ipv6Addr::is_unique_local
- Ipv6Addr::is_unicast_link_local
- core::ptr::with_exposed_provenance
- core::ptr::with_exposed_provenance_mut
- ::addr
- ::expose_provenance
- ::with_addr
- ::map_addr
- ::isqrt
- ::checked_isqrt
- ::isqrt
- NonZero::isqrt
- core::ptr::without_provenance
- core::ptr::without_provenance_mut
- core::ptr::dangling
- core::ptr::dangling_mut
- Pin::as_deref_mut
- Il segnale «const» è stato applicato nelle funzioni:
- AtomicBool::from_ptr
- AtomicPtr::from_ptr
- AtomicU8::from_ptr
- AtomicU16::from_ptr
- AtomicU32::from_ptr
- AtomicU64::from_ptr
- AtomicUsize::from_ptr
- AtomicI8::from_ptr
- AtomicI16::from_ptr
- AtomicI32::from_ptr
- AtomicI64::from_ptr
- AtomicIsize::from_ptr
- ::is_null
- ::as_ref
- ::as_mut
- Pin::new
- Pin::new_unchecked
- Pin::get_ref
- Pin::into_ref
- Pin::get_mut
- Pin::get_unchecked_mut
- Pin::static_ref
- Pin::static_mut
- È stata stabilizzata la supporto per inserimenti inline di assembly per le architetture s390x e Arm64EC.
- Per la piattaforma target WebAssembly è stata stabilizzata la funzionalità multivalue, reference-types e tail-call.
- È stata implementata un secondo livello di supporto per la piattaforma wasm32v1-none. Il secondo livello di supporto implica la garanzia della build.
In aggiunta, si possono menzionare diversi progetti correlati a Rust:
- È stato pubblicato il rilascio del sistema operativo Tock 2.2, scritto in linguaggio Rust e progettato per l'uso in microcontrollori. Il sistema consente l'esecuzione contemporanea di più applicazioni non affidabili su dispositivi embedded, che hanno una dimensione limitata della RAM, come sensori, TPM (Trusted Platform Module), telecomandi per l'autenticazione e dispositivi indossabili. Sono supportate piattaforme con microcontrollori basati sulle architetture ARM Cortex-M e RISC-V. La caratteristica principale di Tock è l'isolamento dei livelli delle applicazioni, del kernel e del layer dei driver, nonché l'isolamento di ogni applicazione e driver singolarmente. Per l'isolamento si utilizzano sia le capacità del linguaggio Rust sia la divisione a livello di protezione della memoria.
- Il progetto VEKOS (Verified Experimental Kernel OS) sviluppa un kernel di sistema operativo in linguaggio Rust, garantendo la verifica dei componenti eseguiti. Ad ogni operazione con il file system, creazione di processi e allocazione di memoria, viene generata una conferma crittografica che consente di verificare l'operazione durante l'esecuzione (l'implementazione è paragonata all'uso della blockchain per la verifica delle azioni nel sistema operativo). Nel file system VKFS, per garantire l'integrità e la protezione da manomissioni retroattive, viene utilizzata una struttura ad albero di Merkle, in cui ogni ramo verifica tutti i rami e i nodi sottostanti, grazie all'hash tree. L'allocazione di memoria avviene in modalità COW (Copy-On-Write).
- Un gruppo di ricercatori di Microsoft e Inria sta sviluppando un sottoinsieme del linguaggio C — Mini-C, destinato alla traslitterazione automatica di programmi scritti in C in una rappresentazione in Rust. A differenza del compilatore c2rust, il nuovo progetto consente di generare codice Rust senza l'uso di unsafe, ma è principalmente rivolto alla trasformazione di progetti C che possiedono una prova formale di affidabilità. Si presume che sia più semplice, inizialmente, tradurre un progetto C in una rappresentazione in Mini-C, in cui non sono permesse operazioni aritmetiche con puntatori, piuttosto che riscrivere blocchi unsafe dopo una compilazione diretta da C a Rust.
L'implementazione del compilatore si basa sugli strumenti KaRaMeL. Mini-C è stato sviluppato e testato nell'ambito di un progetto per riscrivere in Rust la libreria crittografica HACL*, per la quale è stata fornita una dimostrazione formale di affidabilità. Questa dimostrazione è stata utilizzata per dimostrare la capacità di generare codice sicuro in Rust a partire da Mini-C.
- Daniel Stenberg, autore dell'utility curl, ha annunciato la cessazione dello sviluppo e del supporto del progetto Curl per un backend HTTP alternativo scritto in Rust utilizzando la libreria Hyper. Come motivo è stata citata la mancanza di interesse da parte di sviluppatori e utenti.
- È stata annunciata la versione beta della shell Fish 4.0, riscritta in Rust. Si segnala che dopo due anni di sviluppo, il codice sorgente di Fish è stato completamente trasferito da C++ a Rust. Il passaggio a Rust ha permesso di risolvere i problemi di multithreading, di ottenere strumenti moderni che rilevano errori in fase di compilazione, di aumentare la sicurezza nella gestione della memoria e di rendere il progetto più attraente per i nuovi sviluppatori.
- Il progetto Tor ha pubblicato la versione Arti 1.3.2, un'implementazione alternativa del client Tor in Rust. Arti fornisce una libreria incorporabile che può essere utilizzata da diverse applicazioni. Nella creazione di Arti è stata tenuta in considerazione l'esperienza passata nello sviluppo di Tor per evitare noti problemi architetturali, rendere il progetto più modulare ed efficiente. La versione 1.x è contrassegnata come adatta all'uso da parte degli utenti normali e garantisce lo stesso livello di riservatezza, usabilità e stabilità della versione principale in C. Nella nuova versione è proseguito lo sviluppo di RPC, è stata preparata l'implementazione del supporto per i relay e sono state aggiunte misure contro attacchi DoS ai servizi Onion.
- È stata pubblicata la versione del motore di gioco Bevy 0.15, scritto in Rust. Il motore adotta un modello data-driven per la definizione della logica di gioco, costruito su un insieme di componenti pronti Bevy ECS (Entity Component System), che possono essere eseguiti in parallelo. Sono supportati rendering 2D e 3D, animazione scheletrica, definizione del grafo di rendering, sistema di creazione delle scene, framework per la costruzione dell'interfaccia utente, modifica delle scene e delle risorse senza necessità di riavvio.
- È stato pubblicato il editor di testo in console Helix 25.01, scritto in Rust e che ampliando le idee alla base di vim e neovim. Supporta l'integrazione con i server LSP e con Tree-sitter, l'evidenziazione simultanea di più blocchi, l'uso di più cursori durante la modifica, temi di design e il protocollo di debug DAP (Debug Adapter Protocol).
- Il motore del browser Servo, scritto in Rust, ha aggiunto il supporto per la modalità scura. La dimensione del browser ServoShell è stata ridotta del 20%. Il supporto per le specifiche web è stato aggiornato per consentire l'accesso e la lettura dei messaggi su Discord (inviando messaggi al momento non è possibile).
- Mozilla ha presentato il toolkit Uniffi per React Native per creare moduli per React Native in Rust.
- È stata condotta una valutazione delle prestazioni dei codificatori di immagini nel formato PNG. I decodificatori in Rust (png, zune-png, wuffs) risultano più veloci dei decodificatori in C (libpng, spng, stb_image). Ad esempio, il pacchetto crate png (image-rs) ha superato libpng di 1,8 volte su un sistema x86 e di 1,5 volte su un sistema ARM. image-rs: 375.401 MP/s (media) 318.632 MP/s (geomean) zune-png: 376.649 MP/s (media) 302.529 MP/s (geomean) wuffs: 376.205 MP/s (media) 287.181 MP/s (geomean) libpng: 208.906 MP/s (media) 173.034 MP/s (geomean) spng: 299.515 MP/s (media) 235.495 MP/s (geomean) stb_image: 234.353 MP/s (media) 171.505 MP/s (geomean)
Fonte: opennet.ru
