När ska du använda Rust och när ska du använda Go

Det finns tydliga skillnader mellan Go och Rust. Go har ett starkare fokus på att bygga webb-API:er och små tjänster som kan skalas i all oändlighet, särskilt med kraften hos goroutiner. Det sistnämnda är också möjligt med Rust, men det är mycket svårare ur utvecklarens erfarenhetssynpunkt.

Rust fungerar bra för behandling av stora datamängder och andra CPU-intensiva operationer, som att exekvera algoritmer. Detta är Rusts största fördel jämfört med Go. Projekt som kräver hög prestanda lämpar sig generellt sett bättre för Rust.

I den här handledningen kommer vi att jämföra och kontrastera Go och Rust och utvärdera varje programmeringsspråk med avseende på prestanda, samtidighet, minneshantering och den övergripande utvecklarupplevelsen. Vi presenterar också en översikt över dessa element för att hjälpa dig att välja rätt språk för ditt projekt vid en överblick.

Om du bara börjar med Rust kan det vara en bra idé att fräscha upp den här nybörjarguiden innan du läser vidare.

Om du är helt uppdaterad kan vi dyka in!

Prestanda

Originellt utformad av Googles ingenjörer introducerades Go för allmänheten 2009. Det skapades för att erbjuda ett alternativ till C++ som var lättare att lära sig och koda och som var optimerat för att köras på flerkärniga CPU:er.

Sedan dess har Go varit utmärkt för utvecklare som vill dra nytta av den samtidighet som språket erbjuder. Språket tillhandahåller goroutiner som gör det möjligt att köra funktioner som underprocesser.

En stor fördel med Go är hur enkelt det är att använda goroutiner. Det räcker med att lägga till go-syntaxen till en funktion för att få den att köras som en underprocess. Go:s samtidighetsmodell gör det möjligt att distribuera arbetsbelastningar över flera CPU-kärnor, vilket gör det till ett mycket effektivt språk.

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

Trots stödet för flerkärniga CPU:er lyckas Rust fortfarande överträffa Go. Rust är effektivare när det gäller att utföra algoritmer och resurskrävande operationer. Benchmarks Game jämför Rust och Go för olika algoritmer, till exempel binära träd. För alla testade algoritmer var Rust minst 30 procent snabbare; när det gäller beräkningar av binära träd var det upp till 1 000 procent. En studie från Bitbucket visar liknande resultat där Rust presterar i nivå med C++.

(Källa: Benchmarks Game)

Concurrency

Som nämnts ovan har Go stöd för samtidighet. Låt oss till exempel säga att du kör en webbserver som hanterar API-förfrågningar. Du kan använda Gos goroutiner för att köra varje begäran som en underprocess, vilket maximerar effektiviteten genom att avlasta uppgifter till alla tillgängliga CPU-kärnor.

Goroutiner är en del av Gos inbyggda funktioner, medan Rust endast har fått inbyggd async/await-syntax för att stödja samtidighet. Som sådan går fördelen för utvecklarens erfarenhet till Go när det gäller samtidighet. Rust är dock mycket bättre på att garantera minnessäkerhet.

Här är ett exempel på förenklade trådar för 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!");}

Concurrency har alltid varit ett knivigt problem för utvecklare. Det är ingen lätt uppgift att garantera minnessäker samtidighet utan att äventyra utvecklarens upplevelse. Detta extrema säkerhetsfokus ledde dock till skapandet av bevisligen korrekt samtidighet. Rust experimenterade med begreppet ägande för att förhindra oönskad tillgång till resurser för att förhindra minnessäkerhetsfel.

Rust erbjuder fyra olika parallellitetsparadigm för att hjälpa dig att undvika vanliga fallgropar för minnessäkerhet. Vi ska titta närmare på två vanliga paradigm: kanal och lås.

Kanal

En kanal hjälper till att överföra ett meddelande från en tråd till en annan. Det här konceptet finns även i Go, men Rust gör det möjligt att överföra en pekare från en tråd till en annan för att undvika tävlingsvillkor för resurser. Genom att överföra pekare kan Rust genomdriva trådisolering för kanaler. Återigen visar Rust sin besatthet av minnessäkerhet när det gäller dess samtidighetsmodell.

Lock

Data är endast tillgängliga när låset hålls. Rust förlitar sig på principen att låsa data istället för torsk, vilket ofta förekommer i programmeringsspråk som Java.

För mer information om begreppet ägande och alla samtidighetsparadigm kan du läsa ”Fearless Concurrency with Rust.”

Memory safety

Det tidigare begreppet ägande är ett av Rusts främsta försäljningsargument. Rust tar typsäkerheten, som också är viktig för att möjliggöra minnessäker samtidighet, till nästa nivå.

Enligt Bitbucket-bloggen ”Rusts mycket strikta och pedantiska kompilator kontrollerar varje variabel du använder och varje minnesadress du refererar till. Den undviker möjliga data kapplöpningstillstånd och informerar dig om odefinierat beteende.”

Detta innebär att du inte kommer att hamna i ett buffertöverflöde eller ett kapplöpningstillstånd på grund av Rusts extrema besatthet av minnessäkerhet. Detta har dock också sina nackdelar. Du måste till exempel vara hypermedveten om principerna för minnesallokering när du skriver kod. Det är inte lätt att alltid ha minnessäkerhetsvakten uppe.

Utvecklarens erfarenhet

Först av allt ska vi titta på inlärningskurvan som är förknippad med varje språk. Go har utformats med enkelhet i åtanke. Utvecklare hänvisar ofta till det som ett ”tråkigt” språk, vilket innebär att dess begränsade uppsättning av inbyggda funktioner gör Go lätt att ta till sig.

Det är dessutom så att Go erbjuder ett enklare alternativ till C++ och döljer aspekter som minnessäkerhet och minnesallokering. Rust har ett annat tillvägagångssätt och tvingar dig att tänka på begrepp som minnessäkerhet. Begreppet äganderätt och möjligheten att skicka pekare gör Rust till ett mindre attraktivt alternativ att lära sig. När du ständigt tänker på minnessäkerhet är du mindre produktiv och din kod blir garanterat mer komplex.

Inlärningskurvan för Rust är ganska brant jämfört med Go. Det är dock värt att nämna att Go har en brantare inlärningskurva än mer dynamiska språk som Python och JavaScript.

När du ska använda Go

Go fungerar bra för en mängd olika användningsområden, vilket gör det till ett bra alternativ till Node.js för att skapa webb-API:er. Som Loris Cro påpekar: ”Go:s samtidighetsmodell passar bra för program på serversidan som måste hantera flera oberoende förfrågningar”. Det är just därför Go tillhandahåller goroutiner.

Vad mer, Go har inbyggt stöd för HTTP-webbprotokollet. Du kan snabbt utforma ett litet API med hjälp av det inbyggda HTTP-stödet och köra det som en mikrotjänst. Därför passar Go väl in i mikrotjänstarkitekturen och tillgodoser API-utvecklarnas behov.

Samt sett passar Go bra om du värdesätter utvecklingshastighet och föredrar syntaxens enkelhet framför prestanda. Dessutom erbjuder Go bättre kodläsbarhet, vilket är ett viktigt kriterium för stora utvecklingsteam.

Välj Go när:

• Du bryr dig om enkelhet och läsbarhet
• Du vill ha en enkel syntax för att snabbt skriva kod
• Du vill använda ett mer flexibelt språk med stöd för webbutveckling

När du ska använda Rust

Rust är ett utmärkt val när prestandan är viktig, till exempel när du behandlar stora mängder data. Dessutom ger Rust dig finkornig kontroll över hur trådar beter sig och hur resurser delas mellan trådar.

Å andra sidan kommer Rust med en brant inlärningskurva och sänker utvecklingshastigheten på grund av den extra komplexiteten med minnessäkerhet. Detta är inte nödvändigtvis en nackdel; Rust garanterar också att du inte kommer att stöta på minnessäkerhetsbuggar eftersom kompilatorn kontrollerar varje datapekare. För komplexa system kan denna garanti komma väl till pass.

Välj Rust när:

• Du bryr dig om prestanda
• Du vill ha finkornig kontroll över trådar
• Du värderar minnessäkerhet högre än enkelhet

Gå mot Rust: Min ärliga åsikt

Låt oss börja med att lyfta fram likheterna. Både Go och Rust är öppen källkod och utformade för att stödja mikrotjänstarkitektur och parallella datormiljöer. Båda optimerar utnyttjandet av tillgängliga CPU-kärnor genom samtidighet.

Men i slutändan, vilket språk är bäst?

Det finns många sätt att närma sig den här frågan. Jag skulle rekommendera att man funderar på vilken typ av applikation man vill bygga. Go fungerar bra för att skapa webbapplikationer och API:er som drar nytta av dess inbyggda samtidighetsfunktioner och samtidigt stöder mikrotjänstarkitekturen.

Du kan också använda Rust för att utveckla ett webbapplikationsprogram (API), men det har inte utformats med det här användningsfallet i åtanke. Rusts fokus på minnessäkerhet ökar komplexiteten och utvecklingstiden, särskilt för ett ganska enkelt webb-API. Den större mängden kontroll du har över din kod gör dock att du kan skriva mer optimerad, minneseffektiv och presterande kod.

För att uttrycka det så enkelt som möjligt är Go kontra Rust-debatten egentligen en fråga om enkelhet kontra säkerhet.

För fler perspektiv kan du läsa ”Att välja mellan Go och Rust.”