È stata pubblicata la release del linguaggio di programmazione sistemica Rust 1.53, originariamente sviluppato da Mozilla, ma attualmente sviluppato sotto l'egida di un'organizzazione non profit indipendente, la Rust Foundation. Il linguaggio è focalizzato su un utilizzo sicuro della memoria, fornisce una gestione automatica della memoria e offre strumenti per raggiungere un alto livello di parallelismo nell'esecuzione dei task, evitando l'uso di garbage collector e runtime (il runtime si limita alla basic initialization e alla gestione della libreria standard).
La gestione automatica della memoria in Rust libera gli sviluppatori da errori nelle manipolazioni dei puntatori e li protegge dai problemi derivanti da un uso a basso livello della memoria, come l'accesso a zone di memoria dopo che sono state liberate, l’indirezione di puntatori nulli, il superamento dei limiti del buffer, ecc. Per facilitare la distribuzione delle librerie, la costruzione e la gestione delle dipendenze, il progetto è supportato dal gestore dei pacchetti Cargo. Per l'hosting delle librerie è previsto un repository su crates.io.
Novità principali:
- Per gli array è stato implementato il trait IntoIterator, che consente di iterare sugli elementi dell'array per valori: for i in [1, 2, 3] { .. }
È stata anche introdotta la possibilità di passare gli array ai metodi che accettano iteratori, ad esempio: let set = BTreeSet::from_iter([1, 2, 3]); for (a, b) in some_iterator.chain([1]).zip([1, 2, 3]) { .. }
In precedenza, IntoIterator era stato implementato solo per riferimenti agli array, quindi per iterare sui valori era necessario usare riferimenti ('&[1, 2, 3]') o '[1, 2, 3].iter()'. Le implementazioni di IntoIterator per gli array erano ostacolate da problemi di compatibilità, causati dalla conversione precedentemente aggiunta nel compilatore del metodo array.into_iter() in (&array).into_iter(). Tali problemi sono stati risolti in modo indiretto: il compilatore continuerà a convertire array.into_iter() in (&array).into_iter(), come se l'implementazione del trait IntoIterator non fosse presente, ma solo durante la chiamata del metodo utilizzando la sintassi '.into_iter()' e non toccando le chiamate della forma 'in [1, 2, 3]', 'iter.zip([1, 2, 3])', 'IntoIterator::into_iter([1, 2, 3])'.
- È stata data la possibilità di specificare espressioni «|» (operazione logica OR) in qualsiasi parte del modello, ad esempio, invece di «Some(1) | Some(2)» ora è possibile scrivere «Some(1 | 2)»: match result { Ok(Some(1 | 2)) => { .. } Err(MyError { kind: FileNotFound | PermissionDenied, .. }) => { .. } _ => { .. } }
- È consentito l'uso di caratteri non ASCII negli identificatori, inclusi tutti i caratteri nazionali definiti nella specifica Unicode UAX 31, ad eccezione dei caratteri emoji. Quando si utilizzano caratteri diversi ma con aspetto simile, il compilatore emetterà un avviso. const BLÅHAJ: &str = «🦈»; struct 人 { 名字: String, } let α = 1; let ｓos = 2; warning: identifier pair considered confusable between ‘ｓ’ and ‘s’
- Una nuova porzione di API è stata tradotta nella categoria stabile, tra cui sono stati stabilizzati:
- array::from_ref
- array::from_mut
- AtomicBool::fetch_update
- AtomicPtr::fetch_update
- BTreeSet::retain
- BTreeMap::retain
- BufReader::seek_relative
- cmp::min_by
- cmp::min_by_key
- cmp::max_by
- cmp::max_by_key
- DebugStruct::finish_non_exhaustive
- Duration::ZERO
- Duration::MAX
- Duration::is_zero
- Duration::saturating_add
- Duration::saturating_sub
- Duration::saturating_mul
- f32::is_subnormal
- f64::is_subnormal
- IntoIterator per array
- {integer}::BITS
- io::Error::Unsupported
- NonZero*::leading_zeros
- NonZero*::trailing_zeros
- Option::insert
- Ordering::is_eq
- Ordering::is_ne
- Ordering::is_lt
- Ordering::is_gt
- Ordering::is_le
- Ordering::is_ge
- OsStr::make_ascii_lowercase
- OsStr::make_ascii_uppercase
- OsStr::to_ascii_lowercase
- OsStr::to_ascii_uppercase
- OsStr::is_ascii
- OsStr::eq_ignore_ascii_case
- Peekable::peek_mut
- Rc::increment_strong_count
- Rc::decrement_strong_count
- slice::IterMut::as_slice
- AsRef per slice::IterMut
- impl SliceIndex per (Bound, Bound)
- Vec::extend_from_within
- È stato implementato un terzo livello di supporto per la piattaforma wasm64-unknown-unknown. Il terzo livello implica supporto di base, ma senza test automatizzati, pubblicazione di build ufficiali e verifica della possibilità di compilare codice.
- Il gestore di pacchetti Cargo è stato impostato per utilizzare per impostazione predefinita il nome «main» per il ramo principale del repository Git (HEAD). Per le dipendenze collocate in repository che utilizzano il nome main invece di master, non è più necessario specificare nelle impostazioni branch = «main».
- Nel compilatore, i requisiti per la versione minima di LLVM sono stati innalzati a LLVM 10.
Inoltre, è importante notare che è stato finanziato il lavoro per sviluppare integrazioni nel kernel Linux di strumenti per lo sviluppo di componenti in linguaggio Rust. Il lavoro sarà svolto nell'ambito del progetto Prossimo sotto l'egida dell'organizzazione ISRG (Internet Security Research Group), fondatrice del progetto Let’s Encrypt e promotrice della diffusione di HTTPS e dello sviluppo di tecnologie per migliorare la sicurezza di Internet. I fondi saranno forniti da Google, che pagherà il lavoro di Miguel Ojeda, autore del progetto Rust-for-Linux. In precedenza, ISRG e Google hanno già finanziato la creazione di un backend HTTP alternativo per l'utilità curl e lo sviluppo di un nuovo modulo TLS per il server http Apache.
Secondo Microsoft e Google, circa il 70% delle vulnerabilità è causato da un utilizzo insicuro della memoria. Si prevede che l'uso del linguaggio Rust per lo sviluppo dei componenti del kernel, come i driver dei dispositivi, ridurrà il rischio di vulnerabilità causate da un uso insicuro della memoria, escludendo errori come l'accesso a una zona di memoria dopo che è stata liberata e l'uscita dai limiti del buffer.
La gestione sicura della memoria in Rust è garantita durante la compilazione attraverso il controllo dei riferimenti, il tracciamento della proprietà degli oggetti e la gestione del tempo di vita degli oggetti (ambito di visibilità), nonché attraverso la valutazione della correttezza dell'accesso alla memoria durante l'esecuzione del codice. Rust fornisce anche strumenti per proteggersi dai sovraccarichi interi, richiede l'inizializzazione obbligatoria dei valori delle variabili prima dell'uso, gestisce meglio gli errori nella libreria standard, applica il concetto di immutabilità (immutable) per riferimenti e variabili per impostazione predefinita e offre una forte tipizzazione statica per minimizzare gli errori logici.
Fonte: opennet.ru
