È stato pubblicato il rilascio del linguaggio di programmazione general-purpose Rust 1.84, fondato dal progetto Mozilla, ma ora sviluppato sotto gli auspici dell'organizzazione no-profit indipendente Rust Foundation. Il linguaggio si concentra sulla sicurezza della memoria e fornisce i mezzi per ottenere un elevato parallelismo del lavoro evitando l'uso di un Garbage Collector e del runtime (il runtime è ridotto all'inizializzazione di base e alla manutenzione della libreria standard).
I metodi di gestione della memoria di Rust salvano lo sviluppatore da errori durante la manipolazione dei puntatori e proteggono dai problemi che sorgono a causa della gestione della memoria di basso livello, come l'accesso a un'area di memoria dopo che è stata liberata, la dereferenziazione di puntatori nulli, sovraccarichi del buffer, ecc. Per distribuire le librerie, fornire build e gestire le dipendenze, il progetto sviluppa il gestore di pacchetti Cargo. Il repository crates.io è supportato per l'hosting di librerie.
La sicurezza della memoria viene fornita in Rust in fase di compilazione attraverso il controllo dei riferimenti, tenendo traccia della proprietà dell'oggetto, tenendo traccia della durata dell'oggetto (scopi) e valutando la correttezza dell'accesso alla memoria durante l'esecuzione del codice. Rust fornisce anche protezione contro gli overflow di numeri 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, offre una forte tipizzazione statica per ridurre al minimo gli errori logici.
Principali innovazioni:
- Il gestore di pacchetti Cargo ha un meccanismo di elaborazione delle dipendenze stabilizzato 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). La nuova funzionalità elimina la necessità per i manutentori di selezionare manualmente le versioni precedenti di ciascuna dipendenza nei progetti che rimangono compatibili con le versioni precedenti del toolkit Rust. La nuova modalità di risoluzione delle dipendenze sarà abilitata per impostazione predefinita nella versione Rust 1.85, ma per ora è disponibile come opzione che può essere abilitata specificando 'incompatibili-rust-versions = " nella sezione "[resolver]" del file ". cargo/config.toml" file. fallback"'.
- Abbiamo iniziato a convertire il compilatore in un nuovo risolutore di tipi, progettato per testare i limiti di applicabilità dei tratti, normalizzare i tipi e valutare la compatibilità dei tipi. Nella versione 1.84, viene utilizzato un nuovo gestore per verificare la coerenza delle implementazioni dei tratti, ad es. valutare l'esistenza di al massimo un tratto per il tipo in questione, tenendo conto del codice di altri pacchetti di casse. Questo controllo ci ha permesso di eliminare i problemi nella vecchia implementazione del gestore di tipi che potevano potenzialmente portare a conflitti a causa dell'intersezione di diverse implementazioni di tipi.
- È stata proposta una nuova API “Strict Provenance” che può essere utilizzata per convertire un puntatore in un numero intero e viceversa, tenendo conto dei metadati allegati al puntatore con informazioni sulla sua origine e area di utilizzo (oltre a l'indirizzo, il valore di "provenienza" è allegato al puntatore con informazioni sulla connessione con altri puntatori , che consente di determinare dove e quando il puntatore può accedere alla memoria). Quando si lancia un puntatore su un numero intero e viceversa, si verifica un comportamento indefinito a causa della difficoltà di tracciare l'origine del puntatore risultante. La nuova API consente di eseguire operazioni del puntatore di basso livello, come la memorizzazione di informazioni aggiuntive nei bit di ordine inferiore del puntatore, senza convertire il puntatore in un numero intero.
- Una nuova porzione dell'API è stata spostata nella categoria stabile, inclusi i metodi e le implementazioni dei tratti sono stati stabilizzati:
- Ipv6Addr::is_unique_local
- Ipv6Addr::is_unicast_link_local
- core::ptr::with_exposed_provenance
- core::ptr::with_exposed_provenance_mut
- ::Indirizzo
- ::esporre_provenienza
- ::con_ind
- ::indirizzo_mappa
- ::isqrt
- ::checked_isqrt
- ::isqrt
- NonZero::isqrt
- core::ptr::senza_provenienza
- core::ptr::without_provenance_mut
- core::ptr::pendente
- core::ptr::dangling_mut
- Pin::as_deref_mut
- Il segno “const” viene utilizzato 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
- ::è_nullo
- ::come_rif
- ::as_mut
- Perno::nuovo
- Pin::new_unchecked
- Pin::get_ref
- Pin::in_ref
- Pin::get_mut
- Pin::get_unchecked_mut
- Pin::rif._statico
- Pin::static_mut
- Il supporto per gli inserti in linea assembler per le architetture s390x e Arm64EC è stato stabilizzato.
- Il supporto per funzionalità multivalore, tipi di riferimento e chiamate di coda è stato stabilizzato per la piattaforma di destinazione WebAssembly.
- È stato implementato il secondo livello di supporto per la piattaforma wasm32v1-none. Il secondo livello di supporto prevede una garanzia di montaggio.
Inoltre, si possono notare diversi progetti relativi a Rust:
- È stata pubblicata la versione del sistema operativo Tock 2.2, scritto in linguaggio Rust e finalizzato all'utilizzo nei microcontrollori. Il sistema consente l'esecuzione simultanea di più applicazioni non attendibili su dispositivi embedded con dimensioni RAM limitate, come sensori, TPM (Trusted Platform Module), chiavi di autenticazione e dispositivi indossabili. Sono supportate piattaforme con microcontrollori basate su architetture ARM Cortex-M e RISC-V. Una caratteristica fondamentale di Tock è l'isolamento dei livelli applicazione, kernel e driver, nonché l'isolamento di ciascuna applicazione e driver separatamente. L'isolamento utilizza sia le capacità del linguaggio Rust che la separazione a livello di protezione della memoria.
- Il progetto VEKOS (Verified Experimental Kernel OS) sviluppa un kernel del sistema operativo nel linguaggio Rust, che fornisce la verifica dei componenti eseguibili. Per ogni operazione del file system, creazione di processi e allocazione di memoria, viene generata una prova crittografica che consente di verificare l'operazione durante l'esecuzione (l'implementazione è paragonata all'utilizzo di una blockchain per verificare le azioni nel sistema operativo). Nel file system VKFS, per garantire integrità e protezione da distorsioni retroattive, viene utilizzata la struttura Merkle Tree, in cui ogni ramo verifica tutti i rami e i nodi sottostanti, grazie all'hashing dell'albero. L'allocazione della memoria viene eseguita in modalità COW (Copy-On-Write).
- Un gruppo di ricercatori di Microsoft e Inria sta sviluppando un sottoinsieme del linguaggio C, Mini-C, progettato per tradurre automaticamente i programmi C in una rappresentazione Rust. A differenza del compilatore c2rust, il nuovo progetto permette di generare codice Rust senza utilizzare unsafe, ma è finalizzato principalmente alla conversione di progetti C che abbiano una prova formale di affidabilità. L'implicazione è che sarà più semplice convertire prima un progetto C in una rappresentazione Mini-C che non consente l'aritmetica dei puntatori piuttosto che riscrivere i blocchi non sicuri dopo aver compilato direttamente da C a Rust.
L'implementazione del compilatore è basata sul toolkit KaRaMeL. Mini-C è stato sviluppato e testato come parte di un progetto per riscrivere la libreria crittografica HACL* in Rust, per il quale è stata fornita una prova formale di affidabilità. Una prova simile è stata utilizzata per dimostrare la capacità di generare codice Rust sicuro da Mini-C.
- Daniel Stenberg, l'autore dell'utilità curl, ha annunciato che il progetto Curl non svilupperà e manterrà più un backend HTTP alternativo scritto in Rust utilizzando la libreria Hyper. Il motivo addotto è la mancanza di interesse da parte degli sviluppatori e degli utenti.
- È stata annunciata la versione beta della shell dei comandi Fish 4.0, riscritta in Rust. Da notare che dopo due anni di sviluppo, il codice base di Fish è stato completamente trasferito da C++ a Rust. Il passaggio a Rust ci ha permesso di risolvere problemi con il multithreading, ottenere strumenti moderni che rilevano errori in fase di compilazione, migliorare la sicurezza della memoria e rendere il progetto più attraente per i nuovi sviluppatori.
- Il progetto Tor ha pubblicato il rilascio di Arti 1.3.2, un'implementazione alternativa del client Tor in Rust. Arti fornisce una libreria incorporabile che può essere utilizzata da varie applicazioni. Durante la creazione di Arti, è stata presa in considerazione l'esperienza passata nello sviluppo di Tor per evitare problemi architetturali noti e rendere il progetto più modulare ed efficiente. Il ramo 1.x è contrassegnato come adatto all'uso da parte di utenti generici e fornisce lo stesso livello di privacy, usabilità e stabilità dell'implementazione C principale. La nuova versione continua lo sviluppo di RPC, sono stati fatti i preparativi per implementare il supporto di inoltro ed è stata aggiunta la protezione contro gli attacchi DoS sui servizi Onion.
- È stato pubblicato il rilascio del motore di gioco Bevy 0.15, scritto in Rust. Il motore utilizza un modello Data Driven per definire la logica del gioco, costruito su una serie di componenti Bevy ECS (Entity Component System) già pronti che possono essere eseguiti in parallelo. Supporta rendering 2D e 3D, animazione scheletrica, definizione di grafici di rendering, sistema di generazione di scene, struttura dell'interfaccia utente, apportando modifiche a scene e risorse senza la necessità di riavviare.
- È stato pubblicato l'editor di testo per console Helix 25.01, scritto in Rust e ampliando le idee inerenti a vim e neovim. Supporta l'integrazione con server LSP e Tree-sitter, selezione simultanea di più blocchi, utilizzo di più cursori durante la modifica, temi e protocollo di debug DAP (Debug Adapter Protocol).
- Il motore del browser Servo, scritto in Rust, ha aggiunto il supporto per una modalità di progettazione oscura. La dimensione del browser ServoShell è stata ridotta del 20%. Il supporto per le specifiche web è stato esteso alla possibilità di accedere e leggere i messaggi in Discord (l'invio di messaggi non è ancora possibile).
- Mozilla ha introdotto il toolkit Uniffi per React Native per la creazione di moduli per React Native nel linguaggio Rust.
- Le prestazioni dei codificatori di immagini PNG sono state testate. I decodificatori Rust (png, zune-png, wuffs) si sono rivelati più veloci dei decodificatori 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 (geomeana) zune-png: 376.649 MP/s (media) 302.529 MP/s (geomeana) wuffs: 376.205 MP/s (media) 287.181 MP/s ( geomeano) libpng: 208.906 MP/s (media) 173.034 MP/s (geomeana) spng: 299.515 MP/s (media) 235.495 MP/s (geomeana) stb_image: 234.353 MP/s (media) 171.505 MP/s (geomeana)
Fonte: opennet.ru
