È stato rilasciato il linguaggio di programmazione di uso generale Rust 1.84, originariamente sviluppato da Mozilla, ora sostenuto da una organizzazione non-profit indipendente, la Rust Foundation. Il linguaggio è focalizzato sulla gestione sicura della memoria e offre strumenti per raggiungere un elevato parallelismo nell'esecuzione dei compiti, senza l'uso di un garbage collector né di un runtime (il runtime si limita alla configurazione di base e al supporto della libreria standard).
I metodi di gestione della memoria in Rust liberano gli sviluppatori dagli errori nella manipolazione dei puntatori e li proteggono da problematiche derivanti dal lavoro a basso livello con la memoria, come l'accesso a zone di memoria dopo la loro liberazione, la dereferenziazione di puntatori nulli, il superamento dei limiti del buffer, e così via. Per la distribuzione delle librerie, la gestione della compilazione e delle dipendenze, si è sviluppato un gestore di pacchetti chiamato Cargo. Le librerie sono ospitate nel repository crates.io.
La gestione sicura della memoria in Rust è garantita durante la compilazione tramite il controllo dei riferimenti, il tracciamento della proprietà degli oggetti, la gestione della durata degli oggetti (scope) e la valutazione della correttezza dell'accesso alla memoria durante l'esecuzione del codice. Rust offre anche strumenti per proteggere da overflow interi, richiede l'inizializzazione obbligatoria dei valori 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 ridurre al minimo gli errori logici.
Novità principali:
- Nel gestore di pacchetti Cargo è stato stabilizzato un meccanismo per la gestione delle dipendenze, che seleziona le versioni dei componenti dipendenti tenendo conto della compatibilità con le versioni del compilatore Rust dichiarate come quelle minimamente supportate dal progetto (MSRV, Minimum Supported Rust Version). Questa nuova funzionalità consente di liberare i manutentori dalla necessità di scegliere manualmente le versioni obsolete di ogni dipendenza nei progetti che devono mantenere la compatibilità con le vecchie versioni degli strumenti Rust. La nuova modalità di determinazione delle dipendenze sarà attivata per impostazione predefinita nella versione Rust 1.85, ma è attualmente disponibile come opzione, da attivare specificando ‘incompatible-rust-versions = «fallback»‘ nella sezione «[resolver]» del file «.cargo/config.toml».
- È iniziata la traduzione del compilatore verso un nuovo gestore di tipi (trait solver), progettato per controllare i limiti di applicabilità dei trait, normalizzare i tipi e valutare la compatibilità dei tipi. Nella versione 1.84, il nuovo gestore è stato attivato per verificare la coerenza delle implementazioni dei trait, cioè per valutare l'esistenza di non più di un trait per il tipo in questione, tenendo conto del codice proveniente da altri pacchetti crate. Questo controllo ha permesso di eliminare problemi nella vecchia implementazione del gestore di tipi, che potevano potenzialmente portare a conflitti a causa della sovrapposizione di diverse implementazioni dei trait.
- È stato proposto un nuovo API "Strict Provenance", che può essere utilizzato per convertire un puntatore in un numero intero e viceversa, tenendo conto dei metadati allegati al puntatore che forniscono informazioni sulla sua origine e ambito di utilizzo (oltre all'indirizzo del puntatore, viene allegato il valore "provenance" con informazioni sui legami con altri puntatori, consentendo di determinare dove e quando il puntatore può accedere alla memoria). Durante la conversione del puntatore in un numero intero e viceversa, si verificano comportamenti indefiniti a causa delle difficoltà di tracciare l'origine del puntatore risultante. Il nuovo API consente di eseguire operazioni a basso livello con i puntatori, come il salvataggio di informazioni aggiuntive nei bit inferiori del puntatore, senza la necessità di convertirlo in un numero intero.
- Una nuova serie di API è stata traslata nella categoria stabile, stabilizzando i metodi e le implementazioni dei tipi:
- 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 flag «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
- La supporto per le inserzioni inline di assembler è stato stabilizzato per le architetture s390x e Arm64EC.
- Per la piattaforma di destinazione WebAssembly, il supporto per le funzionalità multivalue, reference-types e tail-call è stato stabilizzato.
- È stato implementato il secondo livello di supporto per la piattaforma wasm32v1-none. Il secondo livello di supporto implica una garanzia di compilazione.
Inoltre, si possono citare diversi progetti legati a Rust:
- È stato pubblicato il rilascio del sistema operativo Tock 2.2, sviluppato in Rust e progettato per l'uso in microcontrollori. Il sistema consente l'esecuzione contemporanea di più applicazioni non affidabili su dispositivi embedded con memoria RAM limitata, come sensori, TPM (Trusted Platform Module), chiavi di autenticazione e dispositivi indossabili. Supporta piattaforme con microcontrollori basati su architetture ARM Cortex-M e RISC-V. Una caratteristica chiave di Tock è l'isolamento dei livelli delle applicazioni, del kernel e del layer dei driver, oltre all'isolamento di ciascuna applicazione e driver singolarmente. Per l'isolamento vengono utilizzate le funzionalità del linguaggio Rust e la separazione 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, alla creazione di un processo e all'allocazione di memoria viene generata una conferma crittografica, che consente di verificare l'operazione durante l'esecuzione (l'implementazione è paragonabile all'uso della blockchain per la verifica delle azioni nel sistema operativo). Nel file system VKFS, per garantire l'integrità e la protezione contro le manomissioni retroattive, viene utilizzata una struttura ad albero di Merkle, dove ciascun ramo verifica tutti i rami e i nodi sottostanti, grazie all'hash tree. L'allocazione della 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, concepito per la traduzione automatica di programmi scritti in C in una rappresentazione in Rust. A differenza del compilatore c2rust, il nuovo progetto permette di generare codice Rust senza l'uso di unsafe, ma si concentra principalmente sulla trasformazione di progetti C che hanno una dimostrazione formale di affidabilità. Si prevede che sarà più semplice prima tradurre un progetto C in una rappresentazione in Mini-C, in cui non sono permesse le operazioni aritmetiche con puntatori, piuttosto che riscrivere i blocchi unsafe dopo una compilazione diretta da C a Rust.
L'implementazione del compilatore si basa sugli strumenti di 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à. Tale dimostrazione è stata utilizzata per dimostrare la possibilità di generare codice sicuro in Rust a partire da Mini-C.
- Daniel Stenberg, autore dell'utilità curl, ha annunciato la cessazione dello sviluppo e del supporto del backend HTTP alternativo di Curl, scritto in Rust utilizzando la libreria Hyper. La causa è attribuita alla mancanza di interesse da parte degli sviluppatori e degli utenti.
- È stata annunciata la beta della shell Fish 4.0, riscritta in Rust. Si osserva che, dopo due anni di sviluppo, il codice sorgente di Fish è stato completamente convertito da C++ a Rust. Il passaggio a Rust ha consentito di risolvere problemi di multithreading, ottenere strumenti moderni per l'individuazione degli errori in fase di compilazione, aumentare la sicurezza nella gestione della memoria e rendere il progetto più attraente per i nuovi sviluppatori.
- Il progetto Tor ha pubblicato la release di Arti 1.3.2, un'alternativa dell'implementazione del client Tor scritta in Rust. Arti offre una libreria integrabile che può essere utilizzata da varie applicazioni. Nello sviluppo di Arti è stata presa in considerazione l'esperienza passata con Tor, per evitare noti problemi architettonici e rendere il progetto più modulare ed efficiente. Il ramo 1.x è segnalato come adatto per l'uso da parte di utenti comuni e garantisce lo stesso livello di riservatezza, usabilità e stabilità dell'implementazione principale in C. Nella nuova versione continuano gli sviluppi per l'RPC, è stata avviata la preparazione per il supporto dei relais e sono state aggiunte protezioni contro attacchi DoS sui servizi Onion.
- È stata pubblicata la versione 0.15 del motore di gioco Bevy, scritto in Rust. Il motore utilizza un modello di definizione della logica di gioco basato su dati (Data Driven), 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 formazione delle scene, framework per la creazione dell'interfaccia utente, e modifiche a scene e risorse senza necessità di riavvio.
- È stato pubblicato l'editor di testo da console Helix 25.01, scritto in Rust e che amplia le idee alla base di vim e neovim. È supportata l'integrazione con i server LSP e con Tree-sitter, la selezione simultanea di più blocchi, l'uso di più cursori durante la modifica, temi di personalizzazione e un 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 di ServoShell è stata ridotta del 20%. Il supporto per le specifiche web è stato ampliato fino a consentire l'accesso e la lettura dei messaggi su Discord (l'invio di messaggi non è ancora possibile).
- Mozilla ha presentato lo strumento Uniffi per React Native, per creare moduli per React Native utilizzando il linguaggio Rust.
- Test delle prestazioni dei codificatori di immagini nel formato PNG. I decodificatori in Rust (png, zune-png, wuffs) sono risultati 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 (media geometrica) zune-png: 376.649 MP/s (media) 302.529 MP/s (media geometrica) wuffs: 376.205 MP/s (media) 287.181 MP/s (media geometrica) libpng: 208.906 MP/s (media) 173.034 MP/s (media geometrica) spng: 299.515 MP/s (media) 235.495 MP/s (media geometrica) stb_image: 234.353 MP/s (media) 171.505 MP/s (media geometrica)
Fonte: opennet.ru
