Mikor használjuk a Rustot és mikor a Go-t

A Go és a Rust között egyértelmű különbségek vannak. A Go nagyobb hangsúlyt fektet a webes API-k és kis szolgáltatások építésére, amelyek a végtelenségig skálázhatók, különösen a goroutine-ok erejével. Ez utóbbi a Rusttal is lehetséges, de a dolgok sokkal nehezebbek a fejlesztői tapasztalat szempontjából.

A Ruszt jól működik nagy mennyiségű adat feldolgozására és egyéb CPU-intenzív műveletekre, például algoritmusok végrehajtására. Ez a Rust legnagyobb előnye a Go-val szemben. A nagy teljesítményt igénylő projektek általában jobban megfelelnek a Rustnak.

Ezzel a bemutatóval összehasonlítjuk és szembeállítjuk a Go-t és a Rustot, értékelve az egyes programozási nyelveket a teljesítmény, az egyidejűség, a memóriakezelés és az általános fejlesztői élmény szempontjából. Ezen elemek áttekintését is bemutatjuk, hogy egy pillantással segíthessünk kiválasztani a megfelelő nyelvet a projektedhez.

Ha most kezdesz el foglalkozni a Rusttal, jó ötlet lehet, ha felfrissíted ezt a kezdőknek szóló útmutatót, mielőtt tovább olvasol.

Ha már mindent elsajátítottál, akkor merüljünk bele!

Teljesítmény

A Go-t eredetileg a Google mérnökei tervezték, és 2009-ben mutatták be a nyilvánosságnak. Azért hozták létre, hogy a C++ alternatíváját kínálja, amelyet könnyebb megtanulni és kódolni, és többmagos CPU-kon való futtatásra optimalizálták.

A Go azóta is nagyszerű a fejlesztők számára, akik ki akarják használni a nyelv által kínált párhuzamosságot. A nyelv goroutine-okat biztosít, amelyek lehetővé teszik a függvények alfolyamatokként való futtatását.

A Go nagy előnye, hogy milyen egyszerűen használhatjuk a goroutine-okat. Egyszerűen hozzáadva a go szintaxist egy függvényhez, az alfolyamatként futtathatóvá válik. A Go párhuzamossági modellje lehetővé teszi, hogy a munkaterheléseket több CPU-magra telepítsük, ami nagyon hatékony nyelvvé teszi.

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")}

A többmagos CPU-támogatás ellenére a Rustnak még mindig sikerül felülmúlnia a Gót. A Rust hatékonyabb az algoritmusok és az erőforrás-igényes műveletek végrehajtásában. A Benchmarks Game összehasonlítja a Rustot és a Go-t különböző algoritmusok, például bináris fák esetében. Az összes tesztelt algoritmus esetében a Rust legalább 30 százalékkal volt gyorsabb, a bináris fák számításánál pedig akár 1000 százalékkal is. A Bitbucket tanulmánya hasonló eredményeket mutat, amelyben a Rust a C++-val egy szinten teljesít.

(Forrás: Benchmarks Game)

Párhuzamosság

Amint már említettük, a Go támogatja az egyidejűséget. Tegyük fel például, hogy egy webkiszolgálót futtatsz, amely API-kéréseket kezel. Használhatja a Go goroutine-ait, hogy minden egyes kérést alfolyamatként futtasson, maximalizálva a hatékonyságot azáltal, hogy a feladatokat az összes rendelkezésre álló CPU-magra terheli.

A goroutine-ok a Go beépített függvényeinek részét képezik, míg a Rust csak natív async/await szintaxist kapott az egyidejűség támogatására. Mint ilyen, a fejlesztői tapasztalat előnye a Go-ra száll, amikor az egyidejűségről van szó. A Rust azonban sokkal jobban garantálja a memóriabiztonságot.

Itt egy példa a Rust egyszerűsített szálaira:

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!");}

Az egyidejűség mindig is kényes probléma volt a fejlesztők számára. Nem könnyű feladat memóriabiztos párhuzamosságot garantálni a fejlesztői élmény veszélyeztetése nélkül. Ez a szélsőséges biztonsági fókusz azonban a bizonyíthatóan helyes párhuzamosság megteremtéséhez vezetett. A Rust kísérletezett a tulajdonlás fogalmával, hogy megakadályozza az erőforrások kéretlen hozzáférését a memóriabiztonsági hibák megelőzése érdekében.

A Rust négy különböző párhuzamossági paradigmát kínál, hogy segítsen elkerülni a gyakori memóriabiztonsági buktatókat. Két gyakori paradigmát nézünk meg közelebbről: a csatornát és a lockot.

Channel

A csatorna segít átadni egy üzenetet az egyik szálról a másikra. Bár ez a koncepció a Go esetében is létezik, a Rust lehetővé teszi egy mutató átvitelét egyik szálról a másikra, hogy elkerüljük az erőforrásokért való versenyfeltételeket. A mutatók átadásával a Rust képes a csatornák szálelszigetelését kikényszeríteni. A Rust ismét megmutatja a memóriabiztonság iránti megszállottságát az egyidejűségi modellje tekintetében.

Lock

Az adatok csak akkor érhetők el, ha a zárat tartjuk. A Rust a cod helyett az adatok zárolásának elvére támaszkodik, ami gyakran megtalálható az olyan programozási nyelvekben, mint a Java.

A birtoklás koncepciójáról és az összes párhuzamossági paradigmáról bővebben a “Fearless Concurrency with Rust.”

Memóriabiztonság

A birtoklás korábbi koncepciója a Rust egyik fő értékesítési pontja. A Rust a következő szintre emeli a típusbiztonságot, ami szintén fontos a memóriabiztos párhuzamosság lehetővé tételéhez.

A Bitbucket blog szerint “A Rust nagyon szigorú és pedáns fordítója minden használt változót és minden memóriacímet ellenőriz, amelyre hivatkozunk. Elkerüli az esetleges adatverseny-állapotokat, és tájékoztat a meghatározatlan viselkedésről.”

Ez azt jelenti, hogy a Rust memóriabiztonsággal kapcsolatos extrém megszállottsága miatt nem fogsz puffer túlcsordulást vagy versenyállapotot kapni. Ennek azonban hátrányai is vannak. Például a kód írása közben hiperfigyelemmel kell lenned a memóriaelosztás elveire. Nem könnyű mindig készenlétben tartani a memóriabiztonságot.

A fejlesztői tapasztalat

Először is nézzük meg az egyes nyelvekhez kapcsolódó tanulási görbét. A Go-t az egyszerűség jegyében tervezték. A fejlesztők gyakran “unalmas” nyelvként emlegetik, ami azt jelenti, hogy a beépített funkciók korlátozott készlete miatt a Go könnyen elsajátítható.

A Go emellett egyszerűbb alternatívát kínál a C++-hoz képest, mivel olyan szempontokat rejt el, mint a memóriabiztonság és a memóriaelosztás. A Rust más megközelítést alkalmaz, és arra kényszerít, hogy olyan fogalmakon gondolkodjunk, mint a memóriabiztonság. A tulajdonjog fogalma és a mutatók átadásának lehetősége a Rustot kevésbé vonzóvá teszi a tanulás szempontjából. Ha állandóan a memóriabiztonságon kell gondolkodnod, kevésbé vagy produktív, és a kódod biztosan bonyolultabb lesz.

A Rust tanulási görbéje elég meredek a Go-hoz képest. Érdemes azonban megemlíteni, hogy a Go tanulási görbéje meredekebb, mint a dinamikusabb nyelveké, például a Pythoné és a JavaScripté.

Mikor használjuk a Go-t

A Go a legkülönbözőbb felhasználási esetekben jól működik, így remek alternatívája a Node.js-nek webes API-k készítéséhez. Ahogy Loris Cro megjegyezte, “a Go párhuzamossági modellje jól alkalmazható olyan szerveroldali alkalmazásokhoz, amelyeknek több független kérést kell kezelniük”. Pontosan ezért a Go biztosítja a goroutine-okat.

Mi több, a Go beépített támogatással rendelkezik a HTTP webes protokollhoz. A beépített HTTP-támogatás segítségével gyorsan megtervezhetünk egy kis API-t, és mikroszolgáltatásként futtathatjuk. Ezért a Go jól illeszkedik a mikroszolgáltatások architektúrájához, és kiszolgálja az API-fejlesztők igényeit.

Röviden, a Go jó választás, ha értékeli a fejlesztés sebességét, és a teljesítmény helyett a szintaxis egyszerűségét részesíti előnyben. Ráadásul a Go jobb kódolvashatóságot kínál, ami fontos kritérium a nagy fejlesztőcsapatok számára.

Válaszd a Go-t, ha:

• Az egyszerűség és az olvashatóság fontos számodra
• Egyszerű szintaxist szeretnél a gyors kódíráshoz
• Egy rugalmasabb nyelvet szeretnél használni, amely támogatja a webfejlesztést

Mikor használd a Rustot

A Rust remek választás, ha a teljesítmény számít, például nagy mennyiségű adat feldolgozásakor. Ráadásul a Rust finom irányítást biztosít a szálak viselkedése és a szálak közötti erőforrás-megosztás felett.

Másrészt a Rust meredek tanulási görbével jár, és a memóriabiztonság extra komplexitása miatt lassítja a fejlesztés sebességét. Ez nem feltétlenül hátrány; a Rust azt is garantálja, hogy nem találkozunk memóriabiztonsági hibákkal, mivel a fordító minden egyes adatmutatót ellenőriz. Összetett rendszerek esetén ez a biztosíték jól jöhet.

Válaszd a Rustot, ha:

• Neked fontos a teljesítmény
• A szálak feletti finom ellenőrzésre vágysz
• A memóriabiztonságot fontosabbnak tartod az egyszerűségnél

Go vs. Rust:

Kezdjük a hasonlóságok kiemelésével. Mind a Go, mind a Rust nyílt forráskódú, és a mikroszolgáltatási architektúra és a párhuzamos számítási környezetek támogatására tervezték. Mindkettő optimalizálja a rendelkezésre álló CPU-magok kihasználását a párhuzamosság révén.

De végső soron melyik nyelv a legjobb?

Ezt a kérdést sokféleképpen lehet megközelíteni. Azt javasolnám, hogy gondolkozzunk el azon, hogy milyen típusú alkalmazást szeretnénk építeni. A Go jól szolgál webes alkalmazások és API-k készítésére, amelyek kihasználják a beépített párhuzamossági funkciókat, miközben támogatják a mikroszolgáltatási architektúrát.

A Rustot is használhatja webes API fejlesztésére, de azt nem erre a felhasználási esetre tervezték. A Rust memóriabiztonságra való összpontosítása növeli a komplexitást és a fejlesztési időt, különösen egy meglehetősen egyszerű webes API esetében. Viszont a nagyobb kontroll a kód felett lehetővé teszi, hogy optimalizáltabb, memóriahatékonyabb és teljesítőképesebb kódot írjunk.

A Go és a Rust közötti vita a lehető legegyszerűbben fogalmazva valójában az egyszerűség és a biztonság kérdése.

További perspektívákért nézze meg a “Choosing between Go and Rust.”