È stato pubblicato il rilascio del linguaggio di programmazione Rust 1.95, originariamente sviluppato da Mozilla e ora gestito sotto l'egida dell'organizzazione indipendente e no profit Rust Foundation. Il linguaggio è focalizzato su un uso sicuro della memoria e fornisce strumenti per raggiungere un alto parallelismo nell'esecuzione dei compiti, il tutto senza ricorrere a un garbage collector e a un runtime (quest'ultimo si limita a una semplice inizializzazione e al supporto della libreria standard).
I metodi di gestione della memoria in Rust mirano a evitare errori nella manipolazione dei puntatori e a proteggere da problemi derivanti dal lavoro a basso livello con la memoria, come l'accesso a porzioni di memoria dopo che sono state liberate, la dereferenziazione di puntatori nulli, l'uscita dai limiti del buffer, ecc. Per la distribuzione delle librerie, la compilazione e la gestione delle dipendenze, viene sviluppato il gestore di pacchetti Cargo. È supportato un repository per la pubblicazione delle librerie, 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:
- È stato aggiunto il macro «cfg_select!», che può essere utilizzato al posto del pacchetto «cfg-if» per la gestione di più condizioni di compilazione in stile blocco «match», senza dover definire una catena di espressioni condizionali con la costruzione «#[cfg]». cfg_select! { unix => { fn foo() { /* unix */ } } target_pointer_width = «32» => { fn foo() { /* non-unix, 32-bit */ } } _ => { fn foo() { /* non unix e non 32-bit */ } } }
- È stata stabilizzata la possibilità di specificare espressioni «if let» all'interno dei blocchi «match» per creare abbinamenti condizionali basati su pattern. In precedenza, il supporto per la specifica di più espressioni «let» utilizzando l'operatore «&&» era stato stabilizzato per i blocchi «if» e «while». match value { Some(x) if let Ok(y) = compute(x) => { println!(«{}, {}», x, y); } _ => {} }
- È stato stabilizzato il supporto per l'assembly inline per le architetture PowerPC e PowerPC64.
- Una nuova serie di API è stata trasformata in versioni stabili, inclusi i metodi stabilizzati e le implementazioni delle trait:
- 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
- Il segnale «const» è stato applicato nelle funzioni:
- fmt::from_fn
- ControlFlow::is_break
- ControlFlow::is_continue
- Nelle versioni stabili degli strumenti è stata rimossa la possibilità di passare al compilatore specifiche per piattaforme target personalizzate.
- Le piattaforme target powerpc64-unknown-linux-musl, aarch64-apple-tvos, aarch64-apple-tvos-sim, aarch64-apple-watchos, aarch64-apple-watchos-sim, aarch64-apple-visionos e aarch64-apple-visionos-sim sono state tradotte al secondo livello di supporto, che implica una garanzia di costruzione, ma senza garanzie per il superamento del test di validazione.
In aggiunta, si possono notare i progetti e gli eventi recentemente annunciati legati a Rust:
- L'azienda Canonical ha presentato il server di visualizzazione Mir 2.26, che offre un set di librerie per la creazione di componenti server basati sul protocollo Wayland e comprende funzionalità standard per i gestori di finestre e i server di visualizzazione. Mir è utilizzato in progetti come il gestore composito Miracle, l'interfaccia per i chioschi internet Ubuntu Frame e l'ambiente desktop Miriway.
La nuova versione è notevole per l'aggiunta della possibilità di sviluppare componenti in Rust. In Rust è stata implementata un'alternativa al sottosistema di gestione degli input evdev-rs e sono stati avviati lavori su un frontend scritto in Rust wayland-rs per Wayland. Tra le modifiche non correlate a Rust in Mir, è stata segnalata la supporto per i protocolli Wayland ext_image_copy_capture_v1 e input-triggers.
- È stata pubblicata la prima versione dell'analizzatore di traffico ayaFlow, scritto in Rust e che utilizza il sottosistema del kernel Linux eBPF per intercettare pacchetti di rete (IPv4/TCP/UDP) e frame Ethernet con un impatto minimo sulle prestazioni. Supporta l'ispezione profonda dei protocolli a livello applicativo (L7), ad esempio, l'estrazione di TLS SNI e delle richieste DNS durante l'analisi del traffico crittografato. Il sistema supporta la manutenzione di una tabella con lo stato attuale delle connessioni in formato DashMap, la memorizzazione della cronologia in SQLite e la restituzione delle statistiche tramite REST API per Prometheus.
- È stata implementata la possibilità di creare applicazioni multi-thread in Rust, utilizzando le funzioni std::thread e eseguite sul lato GPU.
Fonte: opennet.ru
