Cos'è la ruggine? Sviluppo software sicuro, veloce e facile

Veloce, sicuro, facile da scrivere: scegline due. Questo è stato lo stato dello sviluppo del software da molto tempo ormai. I linguaggi che enfatizzano la comodità e la sicurezza tendono ad essere lenti (come Python). I linguaggi che enfatizzano le prestazioni tendono ad essere difficili da lavorare e facili da usare (come C e C ++).

Tutti e tre questi attributi possono essere forniti in un'unica lingua? Ancora più importante, puoi convincere il mondo a lavorarci? Il linguaggio Rust, originariamente creato da Graydon Hoare e attualmente sponsorizzato da Mozilla Research, è un tentativo di fare proprio queste cose. (La lingua di Google Go ha ambizioni simili, ma Rust mira a fare il minor numero possibile di concessioni alle prestazioni.)

Video correlato: Sviluppo di software più sicuro con Rust

Mettiti al passo rapidamente con il nuovo arrivato Rust, progettato per creare software veloce a livello di sistema. Questo spiegatore animato di due minuti mostra come Rust aggira i fastidiosi problemi di programmazione della memoria e della gestione.

Rust è pensato per essere veloce, sicuro e ragionevolmente facile da programmare. È anche pensato per essere utilizzato ampiamente, e non finisce semplicemente per essere una curiosità o un concorso a premi. Ci sono buone ragioni per creare un linguaggio in cui la sicurezza sia su un piano di parità con la velocità e il potere di sviluppo. Dopo tutto, c'è un'enorme quantità di software, alcuni dei quali alla guida di infrastrutture critiche, costruiti con linguaggi in cui la sicurezza non era la prima preoccupazione.

Vantaggi del linguaggio di programmazione Rust

Rust è iniziato come un progetto di ricerca di Mozilla in parte inteso a reimplementare i componenti chiave del browser Firefox. Alcuni motivi chiave hanno spinto a questa decisione: Firefox meritava di fare un uso migliore dei moderni processori multicore; e l'ubiquità dei browser web significa che devono essere sicuri da usare.

Ma questi vantaggi sono necessari a tutti i software, non solo ai browser, motivo per cui Rust si è evoluto in un progetto linguistico da un progetto browser. Rust realizza la sua sicurezza, velocità e facilità d'uso attraverso le seguenti caratteristiche.

La ruggine è veloce

Il codice Rust viene compilato in codice macchina nativo su più piattaforme. I binari sono autonomi, senza runtime e il codice generato è pensato per funzionare come un codice comparabile scritto in C o C ++.

La ruggine è sicura per la memoria

Rust non compilerà programmi che tentano di utilizzare la memoria non sicura. La maggior parte degli errori di memoria vengono rilevati durante l'esecuzione di un programma. La sintassi e le metafore del linguaggio di Rust assicurano che i problemi comuni relativi alla memoria in altri linguaggi - puntatori nulli o penzolanti, corse di dati e così via - non vengano mai messi in produzione. Il compilatore segnala questi problemi e li obbliga a risolverli prima che il programma venga eseguito.

La ruggine è bassa

Rust controlla la gestione della memoria tramite regole rigide. Il sistema di gestione della memoria di Rust è espresso nella sintassi del linguaggio attraverso una metafora chiamata proprietà . Qualsiasi valore dato nella lingua può essere "posseduto", o mantenuto e manipolato, solo da una singola variabile alla volta.

Il modo in cui la proprietà viene trasferita tra gli oggetti è strettamente regolato dal compilatore, quindi non ci sono sorprese in fase di esecuzione sotto forma di errori di allocazione della memoria. L'approccio basato sulla proprietà significa anche che non esiste una gestione della memoria raccolta dai rifiuti, come in linguaggi come Go o C #. (Questo dà anche a Rust un ulteriore aumento delle prestazioni.) Ogni bit di memoria in un programma Rust viene tracciato e rilasciato automaticamente attraverso la metafora della proprietà.

La ruggine è flessibile

La ruggine ti lascia vivere pericolosamente se necessario, fino a un certo punto. Le sicurezze di Rust possono essere in parte sospese laddove è necessario manipolare direttamente la memoria, ad esempio dereferenziare un puntatore grezzo alla C / C ++. La parola chiave è in parte , perché le operazioni di sicurezza della memoria di Rust non possono mai essere completamente disabilitate. Anche in questo caso, non devi quasi mai toglierti le cinture di sicurezza per casi d'uso comuni, quindi il risultato finale è un software più sicuro per impostazione predefinita.

La ruggine è facile da usare

Nessuna delle funzionalità di sicurezza e integrità di Rust aggiunge molto se non vengono utilizzate. Ecco perché gli sviluppatori e la comunità di Rust hanno cercato di rendere il linguaggio il più utile e accogliente possibile per i nuovi arrivati.

Tutto il necessario per produrre i binari di Rust viene fornito nello stesso pacchetto. I compilatori esterni, come GCC, sono necessari solo se stai compilando altri componenti al di fuori dell'ecosistema Rust (come una libreria C che stai compilando dai sorgenti). Anche gli utenti di Microsoft Windows non sono cittadini di seconda classe; la catena di strumenti Rust è capace lì come lo è su Linux e MacOS.

Rust è multipiattaforma

Rust funziona su tutte e tre le piattaforme principali: Linux, Windows e MacOS. Altri sono supportati oltre a questi tre. Se si desidera eseguire la compilazione incrociata o produrre binari per un'architettura o una piattaforma diversa da quella che si sta attualmente utilizzando, è necessario un po 'più di lavoro, ma una delle missioni generali di Rust è ridurre al minimo la quantità di carichi pesanti necessari per tali lavoro. Inoltre, sebbene Rust funzioni sulla maggior parte delle piattaforme attuali, non è l'obiettivo dei suoi creatori di compilare Rust assolutamente ovunque, solo su qualunque piattaforma sia popolare e ovunque non debbano fare compromessi inutili per farlo.

Rust ha potenti funzionalità linguistiche

Pochi sviluppatori vogliono iniziare a lavorare in una nuova lingua se scoprono che ha meno o più deboli funzionalità rispetto a quelle a cui sono abituati. Le funzionalità del linguaggio nativo di Rust si confrontano favorevolmente con quelle che hanno linguaggi come il C ++: macro, generici, corrispondenza di modelli e composizione (tramite "tratti") sono tutti cittadini di prima classe in Rust.

Rust ha un'utile libreria standard

Una parte della missione più ampia di Rust è incoraggiare gli sviluppatori C e C ++ a usare Rust invece di quei linguaggi ogni volta che è possibile. Ma gli utenti di C e C ++ si aspettano di avere una libreria standard decente: vogliono essere in grado di utilizzare contenitori, raccolte e iteratori, eseguire manipolazioni di stringhe, gestire processi e threading, eseguire I / O di file e di rete e così via. Rust fa tutto questo, e altro ancora, nella sua libreria standard. Poiché Rust è progettato per essere multipiattaforma, la sua libreria standard può contenere solo cose che possono essere portate in modo affidabile su piattaforme. Le funzioni specifiche della piattaforma come epoll di Linux devono essere supportate tramite funzioni in librerie di terze parti come libc, mio ​​o tokio. 

È anche possibile usare Rust senza la sua libreria standard. Un motivo comune per farlo è creare binari che non hanno dipendenze dalla piattaforma, ad esempio un sistema integrato o un kernel del sistema operativo.

Rust ha molte librerie di terze parti o "casse"

Una misura dell'utilità di una lingua è quanto si può fare con essa grazie a terze parti. Cargo, il repository ufficiale per le librerie Rust (chiamato "crates") elenca circa diecimila casse. Un buon numero di questi sono collegamenti API a librerie o framework comuni, quindi Rust può essere utilizzato come opzione linguistica praticabile con quei framework. Tuttavia, la comunità di Rust non fornisce ancora una cura dettagliata o una classifica delle casse in base alla loro qualità e utilità complessiva, quindi non puoi dire cosa funziona bene senza provare tu stesso le cose o interrogare la comunità.

Rust ha un buon supporto IDE 

Ancora una volta, pochi sviluppatori vogliono abbracciare un linguaggio con poco o nessun supporto nell'IDE di loro scelta. Ecco perché Rust ha recentemente introdotto Rust Language Server, che fornisce feedback in tempo reale dal compilatore Rust a IDE come Microsoft Visual Studio Code.

Svantaggi del linguaggio di programmazione Rust

Insieme a tutte le sue capacità attraenti, potenti e utili, Rust ha i suoi svantaggi. Alcuni di questi ostacoli inciampano su nuovi "rustaceans" (come si chiamano i fan di Rust) e vecchietti allo stesso modo. 

La ruggine è nuova

Rust è ancora un linguaggio giovane, avendo rilasciato la sua versione 1.0 solo nel 2015. Quindi, anche se gran parte della sintassi e delle funzionalità del linguaggio di base è stata martellata, molte altre cose attorno ad esso sono ancora fluide.

Le operazioni asincrone, ad esempio, non sono ancora rappresentate bene nella sintassi del linguaggio. Sono in corso lavori per implementare operazioni asincrone tramite asynce awaitparole chiave.

La ruggine è difficile da imparare

Se una cosa su Rust è la più problematica, è quanto possa essere difficile cogliere le metafore di Rust. La proprietà, l'assunzione di prestiti e l'altra gestione della memoria di Rust presumono che facciano impazzire tutti la prima volta. Molti programmatori novizi di Rust hanno un rito comune di passaggio, "combattere il controllo del prestito", in cui scoprono in prima persona quanto sia meticoloso il compilatore nel tenere separate le cose mutabili e immutabili.

La ruggine è complessa

Alcune delle difficoltà derivano dal modo in cui le metafore di Rust rendono il codice più dettagliato rispetto ad altri linguaggi. Ad esempio, la concatenazione di stringhe in Rust non è sempre così semplice come string1+string2. Un oggetto potrebbe essere mutabile e l'altro immutabile. Rust è incline a insistere sul fatto che il programmatore spieghi come gestire queste cose, piuttosto che lasciare che il compilatore indovini.

Un altro esempio: come Rust e C / C ++ lavorano insieme. La maggior parte delle volte, Rust viene utilizzato per collegarsi a librerie esistenti scritte in C o C ++; pochi progetti in C e C ++ vengono riscritti da zero in Rust. (E quando lo sono, tendono a essere riscritti in modo incrementale.)

La road map della lingua Rust

Il team di Rust è consapevole di molti di questi problemi e sta lavorando per migliorarli. Ad esempio, per rendere Rust più facile da lavorare con C e C ++, il team di Rust sta valutando se espandere progetti come bindgen, che genera automaticamente collegamenti Rust al codice C. Il team ha anche in programma di rendere i prestiti e le durate più flessibili e più facili da capire. 

Tuttavia, Rust riesce nel suo obiettivo di fornire un linguaggio di sistema sicuro, concorrente e pratico, in modi in cui altri linguaggi non lo fanno e di farlo in modi che completano il modo in cui già lavorano gli sviluppatori.