Când să folosiți Rust și când să folosiți Go

Din start, există diferențe clare între Go și Rust. Go se concentrează mai mult pe construirea de API-uri web și servicii mici care pot fi extinse la nesfârșit, în special cu puterea goroutine. Acestea din urmă sunt posibile și cu Rust, dar lucrurile sunt mult mai dificile din punctul de vedere al experienței dezvoltatorului.

Rust funcționează bine pentru procesarea unor cantități mari de date și pentru alte operațiuni care necesită un procesor intensiv, cum ar fi executarea de algoritmi. Acesta este cel mai mare avantaj al lui Rust față de Go. Proiectele care necesită performanțe ridicate sunt, în general, mai potrivite pentru Rust.

În acest tutorial, vom compara și contrasta Go și Rust, evaluând fiecare limbaj de programare în ceea ce privește performanța, concurența, gestionarea memoriei și experiența generală a dezvoltatorului. Vom prezenta, de asemenea, o prezentare generală a acestor elemente pentru a vă ajuta să alegeți dintr-o privire limbajul potrivit pentru proiectul dumneavoastră.

Dacă sunteți la început cu Rust, ar putea fi o idee bună să vă puneți la punct cu acest ghid pentru începători înainte de a citi mai departe.

Dacă v-ați pus la punct, haideți să trecem la treabă!

Performanță

Proiectat inițial de inginerii de la Google, Go a fost introdus pentru public în 2009. A fost creat pentru a oferi o alternativă la C++ care să fie mai ușor de învățat și de codat și care să fie optimizat pentru a rula pe procesoare multicore.

De atunci, Go a fost excelent pentru dezvoltatorii care doresc să profite de concurența pe care o oferă limbajul. Limbajul oferă gorutine care vă permit să rulați funcții ca subprocese.

Un mare avantaj al Go este ușurința cu care puteți folosi gorutinele. Simpla adăugare a sintaxei go la o funcție face ca aceasta să fie executată ca un subproces. Modelul de concurență al Go vă permite să distribuiți sarcinile de lucru pe mai multe nuclee CPU, ceea ce îl face un limbaj foarte eficient.

package mainimport ( "fmt" "time")func f(from string) { for i := 0; i < 3; i++ { fmt.Println(from, ":", i) }}func main() { f("direct") go f("goroutine") time.Sleep(time.Second) fmt.Println("done")}

În ciuda suportului pentru CPU cu mai multe nuclee, Rust reușește totuși să depășească Go. Rust este mai eficient în executarea algoritmilor și a operațiilor care necesită multe resurse. The Benchmarks Game compară Rust și Go pentru diverși algoritmi, cum ar fi arborii binari. Pentru toți algoritmii testați, Rust a fost cu cel puțin 30 de procente mai rapid; în cazul calculelor cu arbori binari, a fost de până la 1.000 de procente. Un studiu realizat de Bitbucket arată rezultate similare, în care Rust se comportă la egalitate cu C++.

(Sursa: Benchmarks Game)

Concurrency

După cum am menționat mai sus, Go suportă concurrency. De exemplu, să spunem că rulați un server web care gestionează cereri API. Puteți folosi gorutinele Go pentru a rula fiecare cerere ca un subproces, maximizând eficiența prin descărcarea sarcinilor pe toate nucleele CPU disponibile.

Gorutinele fac parte din funcțiile încorporate în Go, în timp ce Rust a primit doar sintaxa nativă async/await pentru a suporta concurența. Ca atare, avantajul experienței dezvoltatorului îi revine lui Go când vine vorba de simultaneitate. Cu toate acestea, Rust este mult mai bun la garantarea siguranței memoriei.

Iată un exemplu de fire simplificate pentru Rust:

use std::thread;use std::time::Duration;fn main() { // 1. create a new thread for i in 1..10 { thread::spawn(|| { println!("thread: number {}!", i); thread::sleep(Duration::from_millis(100)); }); } println!("hi from the main thread!");}

Concurența a fost întotdeauna o problemă spinoasă pentru dezvoltatori. Nu este o sarcină ușoară de a garanta concurența sigură în memorie fără a compromite experiența dezvoltatorului. Cu toate acestea, această concentrare extremă asupra securității a dus la crearea unei concurențe demonstrabil corecte. Rust a experimentat conceptul de proprietate pentru a preveni accesul nesolicitat la resurse pentru a preveni erorile de siguranță a memoriei.

Rust oferă patru paradigme diferite de concurență pentru a vă ajuta să evitați capcanele comune de siguranță a memoriei. Vom examina mai îndeaproape două paradigme comune: canalul și blocarea.

Canal

Un canal ajută la transferul unui mesaj de la un fir la altul. Deși acest concept există și pentru Go, Rust vă permite să transferați un pointer de la un fir la altul pentru a evita condițiile de cursă pentru resurse. Prin trecerea de pointeri, Rust poate impune izolarea firelor pentru canale. Din nou, Rust își manifestă obsesia pentru siguranța memoriei în ceea ce privește modelul său de concurență.

Lock

Datele sunt accesibile numai atunci când lock-ul este deținut. Rust se bazează pe principiul de blocare a datelor în loc de cod, care se regăsește adesea în limbaje de programare precum Java.

Pentru mai multe detalii despre conceptul de proprietate și toate paradigmele de concurență, consultați „Fearless Concurrency with Rust.”

Siguranța memoriei

Conceptul anterior de proprietate este unul dintre principalele argumente de vânzare ale Rust. Rust duce siguranța tipurilor, care este, de asemenea, importantă pentru a permite concurența sigură pentru memorie, la următorul nivel.

Conform blogului Bitbucket, „compilatorul foarte strict și pedant al lui Rust verifică fiecare variabilă pe care o utilizați și fiecare adresă de memorie la care faceți referire. El evită posibilele condiții de cursă a datelor și vă informează despre comportamente nedefinite.”

Aceasta înseamnă că nu veți ajunge să aveți o depășire de buffer sau o condiție de cursă din cauza obsesiei extreme a lui Rust pentru siguranța memoriei. Cu toate acestea, acest lucru are, de asemenea, dezavantajele sale. De exemplu, trebuie să fiți hiperconștient de principiile de alocare a memoriei în timp ce scrieți codul. Nu este ușor să ai mereu garda de siguranță a memoriei ridicată.

Experiența dezvoltatorului

În primul rând, să ne uităm la curba de învățare asociată cu fiecare limbaj. Go a fost proiectat cu gândul la simplitate. Dezvoltatorii se referă adesea la el ca la un limbaj „plictisitor”, ceea ce înseamnă că setul său limitat de caracteristici încorporate face ca Go să fie ușor de adoptat.

În plus, Go oferă o alternativă mai ușoară la C++, ascunzând aspecte precum siguranța memoriei și alocarea memoriei. Rust are o altă abordare, forțându-vă să vă gândiți la concepte precum siguranța memoriei. Conceptul de proprietate și capacitatea de a trece pointeri face ca Rust să fie o opțiune mai puțin atractivă de învățat. Atunci când vă gândiți în mod constant la siguranța memoriei, sunteți mai puțin productiv, iar codul dumneavoastră va fi cu siguranță mai comlex.

Curba de învățare pentru Rust este destul de abruptă în comparație cu Go. Merită menționat, totuși, că Go are o curbă de învățare mai abruptă decât limbajele mai dinamice, cum ar fi Python și JavaScript.

Când să folosiți Go

Go funcționează bine pentru o mare varietate de cazuri de utilizare, ceea ce îl face o alternativă excelentă la Node.js pentru crearea de API-uri web. După cum a remarcat Loris Cro, „modelul de concurență al lui Go se potrivește foarte bine pentru aplicațiile de tip server care trebuie să gestioneze mai multe cereri independente”. Acesta este exact motivul pentru care Go oferă goroutine.

Ceea ce este mai mult, Go are suport încorporat pentru protocolul web HTTP. Puteți proiecta rapid un mic API folosind suportul HTTP încorporat și îl puteți rula ca un microserviciu. Prin urmare, Go se potrivește bine cu arhitectura microserviciilor și răspunde nevoilor dezvoltatorilor de API-uri.

În concluzie, Go se potrivește bine dacă apreciați viteza de dezvoltare și preferați simplitatea sintaxei în detrimentul performanței. În plus, Go oferă o mai bună lizibilitate a codului, ceea ce reprezintă un criteriu important pentru echipele mari de dezvoltare.

Alegeți Go atunci când:

• Vă interesează simplitatea și lizibilitatea
• Vreți o sintaxă ușoară pentru a scrie rapid codul
• Vreți să folosiți un limbaj mai flexibil care suportă dezvoltarea web

Când să folosiți Rust

Rust este o alegere excelentă atunci când performanța contează, cum ar fi atunci când procesați cantități mari de date. În plus, Rust vă oferă un control fin asupra modului în care se comportă firele de execuție și asupra modului în care sunt partajate resursele între firele de execuție.

Pe de altă parte, Rust vine cu o curbă de învățare abruptă și încetinește viteza de dezvoltare din cauza complexității suplimentare a siguranței memoriei. Acesta nu este neapărat un dezavantaj; Rust garantează, de asemenea, că nu veți întâlni erori de siguranță a memoriei, deoarece compilatorul verifică fiecare pointer de date. Pentru sistemele complexe, această asigurare poate fi utilă.

Alegeți Rust atunci când:

• Vă interesează performanța
• Vreți un control fin asupra firelor de execuție
• Astăzi prețuiți siguranța memoriei în detrimentul simplității

Vezi vs. Rust: Părerea mea sinceră

Să începem prin a sublinia asemănările. Atât Go, cât și Rust sunt open-source și sunt concepute pentru a sprijini arhitectura microserviciilor și mediile de calcul paralel. Ambele optimizează utilizarea nucleelor CPU disponibile prin concurență.

Dar, la sfârșitul zilei, care este cel mai bun limbaj?

Există multe moduri de a aborda această întrebare. V-aș recomanda să vă gândiți la ce tip de aplicație doriți să construiți. Go servește bine pentru crearea de aplicații web și API-uri care profită de caracteristicile sale integrate de simultaneitate, sprijinind în același timp arhitectura microserviciilor.

Puteți folosi, de asemenea, Rust pentru a dezvolta un API web, dar nu a fost proiectat cu acest caz de utilizare în minte. Accentul pus de Rust pe siguranța memoriei crește complexitatea și timpul de dezvoltare, în special pentru un API web destul de simplu. Cu toate acestea, cantitatea mai mare de control pe care o aveți asupra codului dvs. vă permite să scrieți cod mai optimizat, mai eficient din punct de vedere al memoriei și mai performant.

Pentru a spune cât mai simplu posibil, dezbaterea Go versus Rust este de fapt o chestiune de simplitate versus securitate.

Pentru mai multe perspective, consultați „Choosing between Go and Rust.”