Bitfield Consulting

Rust en Go zijn beide awesome

Ten eerste is het erg belangrijk om te zeggen dat zowel Go Als Rust absoluut uitstekende programmeertalen zijn. Ze zijn modern, krachtig, breed aangenomen en bieden uitstekende prestaties. Je hebt misschien gelezen artikelen en blog posts gericht op u te overtuigen dat Go is beter dan Rust, of vice versa. Maar dat heeft echt geen zin; elke programmeertaal vertegenwoordigt een set van trade-offs. Elke taal is geoptimaliseerd voor verschillende dingen, dus uw taalkeuze moet worden bepaald door wat bij u past en de problemen die u ermee wilt oplossen.

In dit artikel zal ik proberen een kort overzicht te geven van waar ik denk dat Go de ideale keuze is, en waar ik denk dat Rust een beter alternatief is. Idealiter, hoewel, moet je een werkende vertrouwdheid met beide talen. Hoewel ze zeer verschillend in syntaxis en stijl, zowel Rust en Go zijn eersteklas tools voor het bouwen van software. Dat gezegd hebbende, laten we eens een kijkje nemen op de twee talen.

de overeenkomsten

Rust en Go hebben veel gemeen, wat een reden is dat je ze vaak samen hoort noemen. Wat zijn enkele van de gemeenschappelijke doelen van beide talen?

Rust is een laag niveau statisch getypte multi-paradigma programmeertaal die gericht is op veiligheid en prestaties.
– Gints Dreimanis

Go is een open source programmeertaal die het eenvoudig maakt om eenvoudige, betrouwbare en efficiënte software te bouwen.
—Golang.org

Geheugenveiligheid

zowel Go als Rust behoren tot de groep moderne programmeertalen met als prioriteit geheugenveiligheid. Het is duidelijk geworden over vele decennia van het gebruik van oudere talen zoals C en c++ dat een van de grootste oorzaken van bugs en beveiligingsproblemen is toegang tot het geheugen onveilig of onjuist. Rust en ga omgaan met dit probleem op verschillende manieren, maar beide streven om slimmer en veiliger dan andere talen over het beheer van het geheugen, en om u te helpen schrijven juiste en performante programma ‘ s.

snelle, compacte uitvoerbare bestanden

het zijn beide gecompileerde talen, wat betekent dat uw programma ‘ s direct worden vertaald naar uitvoerbare machinecode, zodat u uw programma kunt implementeren als een enkel binair bestand; in tegenstelling tot geïnterpreteerde talen zoals Python en Ruby, hoeft u geen interpreter en veel bibliotheken en afhankelijkheden samen met uw programma te distribueren, wat een groot pluspunt is. Dit maakt ook zowel Rust en Go programma ‘ s extreem snel in vergelijking met geïnterpreteerde talen.

Algemene talen

Rust en Go zijn ook krachtige, schaalbare algemene programmeertalen, die u kunt gebruiken om allerlei moderne software te ontwikkelen, van webapplicaties tot gedistribueerde microservices, of van ingebedde microcontrollers tot mobiele apps. Beide hebben uitstekende standaardbibliotheken en een bloeiend ecosysteem van derden, evenals grote commerciële ondersteuning en een grote user base. Ze bestaan allebei al vele jaren en zullen nog jaren op grote schaal gebruikt worden. Het leren van Go Of Rust vandaag zal een goede investering van uw tijd en moeite.

pragmatische programmeerstijl

noch zijn primair functionele talen (zoals Scala of Elixir, bijvoorbeeld), noch zijn uitsluitend objectgeoriënteerd (zoals Java en C#). In plaats daarvan, terwijl zowel Go Als Rust functies hebben die geassocieerd zijn met functioneel en objectgeoriënteerd programmeren, zijn het pragmatische talen die gericht zijn op het oplossen van problemen op welke manier dan ook die het meest geschikt is, in plaats van je te dwingen tot een bepaalde manier om dingen te doen. (Als je van de functionele stijl van programmeren houdt, vind je er echter veel meer faciliteiten voor in Rust, omdat Rust veel meer faciliteiten heeft dan Go in het algemeen.)

We kunnen discussiëren over wat een ‘objectgeoriënteerde’ taal is, maar het is eerlijk om te zeggen dat de stijl van objectgeoriënteerd programmeren die C++, Java of c# gebruikers zouden verwachten niet aanwezig is in Go Of Rust.
– Jack Mott

ontwikkeling op schaal

zowel Rust en Go hebben een aantal handige functies die ze geschikt maken voor het programmeren in de grote, of dat nu grote teams, grote codebases, of beide betekent.

bijvoorbeeld, terwijl C-programmeurs al jaren discussiëren over waar ze hun haakjes moeten plaatsen, en of code moet worden ingesprongen met tabs of spaties, elimineren zowel Rust als Go dergelijke problemen volledig met behulp van een standaard opmaakgereedschap (gofmt voor Go, rustfmt voor Rust) die uw code automatisch herschrijft met behulp van de canonieke stijl. Het is niet dat deze stijl op zich zo prachtig is: het is de standaardisatie die Rust en Go programmeurs waarderen.

> gofmt‘s stijl is niemands favoriet, maar gofmt is ieders favoriet.

—Rob Pike

een ander gebied waar beide talen hoog scoren, bevindt zich in de build pipeline. Beide hebben uitstekende, ingebouwde, high-performance standaard build en afhankelijkheid management tools; niet meer worstelen met complexe derden bouwen systemen en het hebben van een nieuwe om de paar jaar te leren.

Building Go and Rust code, afkomstig uit een Java en Ruby achtergrond in mijn vroege carrière, voelde als een onmogelijke last van mijn schouders. Toen ik bij Google was, was het een opluchting om een dienst tegen te komen die in Go was geschreven, omdat ik wist dat het gemakkelijk zou zijn om te bouwen en te draaien. Dit geldt ook voor Rust, al heb ik daar alleen op veel kleinere schaal aan gewerkt. Ik hoop dat de dagen van oneindig configureerbare bouwsystemen dood zijn, en talen worden allemaal geleverd met hun eigen speciaal gebouwde bouwtools die gewoon uit de doos werken.
– Sam Rose

dus wat is al die drukte over?

met dat alles in gedachten, en aangezien beide talen zo goed ontworpen en krachtig zijn, vraag je je misschien af waar alle heilige oorlogen over gaan (ik ook). Waarom maken mensen zo ‘n ophef over’ Go versus Rust’, krijgen in boze social media spats en het schrijven van lange blog posts over hoe alleen een idioot Rust zou gebruiken, of dat Go is niet een echte programmeertaal, of wat dan ook. Het kan hen beter laten voelen, maar het helpt jou niet echt, als iemand die probeert te beslissen welke taal te gebruiken voor je project, of welke je moet leren om je programmeercarrière vooruit te helpen. Een wijs persoon maakt geen belangrijke keuzes gebaseerd op wie het hardst schreeuwt.

laten we onze volwassen discussie nu voortzetten door te kijken naar sommige gebieden waar een redelijk persoon de voorkeur zou kunnen geven aan de ene taal boven de andere.

Performance

We hebben gezegd dat zowel Go Als Rust extreem snelle programma ‘ s produceren omdat ze zijn gecompileerd naar native machine code, zonder dat ze door een interpreter of virtuele machine hoeven te gaan. De prestaties van Rust zijn echter bijzonder uitstekend. Het is vergelijkbaar met C en c++, die vaak worden beschouwd als de hoogste prestaties gecompileerde talen, maar in tegenstelling tot deze oudere talen, Het biedt ook geheugen veiligheid en concurrency veiligheid op in wezen geen kosten in de uitvoeringssnelheid. Rust kunt u ook complexe abstracties te maken zonder het betalen van een prestatie boete op run-time.

ter vergelijking, hoewel Go-programma ‘ s ook zeer goed presteren, is Go voornamelijk ontworpen voor snelheid van ontwikkeling (inclusief compilatie), in plaats van snelheid van uitvoering. De go compiler besteedt niet veel tijd aan het genereren van de meest efficiënte machine code; het geeft meer om het snel compileren van veel code. Dus Rust zal meestal verslaan gaan in run-time benchmarks.

Rust ‘ s runtime performance is ook consistent en voorspelbaar, omdat het geen garbage collection gebruikt. Go ‘ s garbage collector is zeer efficiënt, en het is geoptimaliseerd om de stop-the-world pauzes zo kort mogelijk te maken (en steeds korter met elke nieuwe go release). Maar garbage collection introduceert onvermijdelijk enige onvoorspelbaarheid in de manier waarop programma ‘ s zich gedragen, wat een ernstig probleem kan zijn in sommige toepassingen, zoals embedded systemen.

omdat Rust erop gericht is de programmeur volledige controle te geven over de onderliggende hardware, is het mogelijk om Rust-programma ‘ s te optimaliseren om vrij dicht bij de maximale theoretische prestaties van de machine te zijn. Dit maakt Rust een uitstekende keuze voor gebieden waar de snelheid van uitvoering verslaat alle andere overwegingen, zoals spel programmering, besturingssysteem kernels, webbrowser componenten, en real-time besturingssystemen.

eenvoud

Het maakt niet uit hoe snel een programmeertaal is als niemand kan achterhalen hoe het te gebruiken. Go werd bewust opgevat als een reactie tegen de steeds toenemende complexiteit van talen als C++; het heeft zeer weinig syntaxis, zeer weinig zoekwoorden, en, inderdaad, weinig functies. Dit betekent dat het niet lang duurt om de Go taal te leren tot het punt waar je nuttige programma ‘ s erin kunt schrijven.

Go is ongelooflijk eenvoudig te leren. Ik weet dat dit een vaak aangeprezen voordeel is, maar ik was echt verbaasd over hoe snel ik in staat was om productief te zijn. Dankzij de taal, documenten en hulpmiddelen, schreef ik na letterlijk twee dagen interessante, verbindbare code.
– vroege impressies van Go From a Rust Programmer

het sleutelwoord hier is eenvoud. Eenvoudig is zeker niet hetzelfde als gemakkelijk, maar een kleine, eenvoudige taal is makkelijker te leren dan een grote, complexe taal. Er zijn gewoon niet veel verschillende manieren om dingen te doen, dus alle goed geschreven Go code heeft de neiging om er hetzelfde uit te zien. Het is gemakkelijk om gewoon te duiken in een onbekende dienst en begrijpen wat het doet.

fmt.Println("Gopher's Diner Breakfast Menu")for dish, price := range menu { fmt.Println(dish, price)}

(In de Code Club-serie doe ik precies dat: kies Go-projecten semi-willekeurig uit GitHub en verken ze met een groep Go-beginners, om te zien hoeveel van de code we kunnen begrijpen. Het blijkt altijd meer te zijn dan we hadden verwacht!)

hoewel de kerntaal klein is, is de standaardbibliotheek van Go zeer krachtig. Dat betekent dat je leercurve ook de delen van de standaardbibliotheek moet bevatten die je nodig hebt, niet alleen syntaxis. Aan de andere kant betekent het verplaatsen van functionaliteit uit de taal naar de standaardbibliotheek dat u zich kunt concentreren op het leren van alleen de bibliotheken die op dit moment voor u relevant zijn.

Go is ook ontworpen voor softwareontwikkeling op schaal, met grote codebases en grote teams. In deze situaties is het belangrijk dat nieuwe ontwikkelaars zo snel mogelijk op de hoogte kunnen komen.

Met Go krijg je dingen snel gedaan. Go is een van de meest productieve talen waar ik ooit mee heb gewerkt. De mantra is: > los echte problemen op vandaag> .
– Matthias Endler

Features

Rust ondersteunt meer complexiteit dan verschillende andere programmeertalen, daarom kunt u er meer mee bereiken. Het ondersteunt bijvoorbeeld generieke geneesmiddelen.
—Devathon

Rust is speciaal ontworpen om veel krachtige en handige functies te bevatten om programmeurs te helpen het meeste te doen met de minste code. Bijvoorbeeld, met de functie match kunt u flexibele, expressieve logica heel bondig schrijven:

fn is_prime(n: u64) -> bool { match n { 0...1 => false, _ => !(2..n).any(|d| n % d == 0), }}

omdat Rust veel doet, betekent dit dat er veel te leren is, vooral aan het begin. Maar dat geeft niet: Er is ook veel te leren in C++ of Java, en je krijgt niet de geavanceerde functies die bij Rust komen, zoals geheugenveiligheid. Om Rust te bekritiseren als een complexe taal mist het punt: het is ontworpen om expressief te zijn, wat betekent dat je veel functies hebt, en in veel situaties is dat wat je wilt van een programmeertaal. Er is zeker een leercurve, maar als je er eenmaal mee bezig bent, komt het goed.

Rust concurreert voor mindshare met C++ en D voor programmeurs die bereid zijn complexere syntaxis en semantiek (en vermoedelijk hogere leesbaarheidskosten) te accepteren in ruil voor de maximaal mogelijke prestaties.
– Dave Cheney

Concurrency

De meeste talen hebben enige vorm van ondersteuning voor gelijktijdig programmeren (meerdere dingen tegelijk doen), maar Go is vanaf de basis ontworpen voor deze taak. In plaats van het gebruik van het besturingssysteem threads, Go biedt een lichtgewicht alternatief: goroutines. Elke goroutine is een onafhankelijk uitvoeren Go functie, die de go scheduler zal toewijzen aan een van de OS threads onder zijn controle. Dit betekent dat de scheduler zeer efficiënt een groot aantal gelijktijdige goroutines kan beheren, met slechts een beperkt aantal OS threads.

bijgevolg kunt u miljoenen gelijktijdige goroutines in een enkel programma draaien zonder ernstige prestatieproblemen te creëren. Dat maakt Go de perfecte keuze voor grootschalige gelijktijdige toepassingen zoals webservers en microservices.

Go biedt ook snelle, veilige, efficiënte manieren voor goroutines om te communiceren en gegevens te delen, met behulp van kanalen. Go ‘ s concurrency ondersteuning voelt goed ontworpen, en een plezier om te gebruiken. Redeneren over gelijktijdige programma ‘s is moeilijk in het algemeen, en het bouwen van betrouwbare, correcte gelijktijdige programma’ s is een uitdaging in elke taal. Omdat het vanaf het begin in de taal is ingebouwd, is gelijktijdige programmering in Go echter niet een bijzaak, maar net zo eenvoudig en goed geïntegreerd als het redelijkerwijs zou kunnen zijn.

Go maakt het heel eenvoudig om een mooi gefactoreerde applicatie te bouwen die ten volle gebruik maakt van concurrency terwijl deze wordt ingezet als een set microservices. Roest kan die dingen ook doen, maar het is misschien een beetje moeilijker. In sommige opzichten, Rust ‘ s obsessie met het voorkomen van geheugen-gerelateerde beveiligingsproblemen betekent dat programmeurs moeten gaan uit hun manier om taken uit te voeren die eenvoudiger zouden zijn in andere talen, met inbegrip van Go.
—Sonya Koptyev

Het concurrency verhaal in Rust is zeer Nieuw, ter vergelijking, en stabiliseert nog steeds, maar het is in zeer actieve ontwikkeling, dus let op deze ruimte. De rayon-bibliotheek van Rust biedt bijvoorbeeld een zeer elegante en lichtgewicht manier om sequentiële berekeningen om te zetten in parallelle berekeningen.

het hebben van lichtgewicht syntaxis voor het paaien van Go routines en het gebruik van kanalen zijn erg leuk. Het toont echt de kracht van syntaxis dat zulke kleine details gelijktijdige programmering zo veel mooier maken dan in andere talen.
– vroege impressies van Go From a Rust Programmer

hoewel het misschien iets minder eenvoudig is om gelijktijdige programma ‘s in Rust te implementeren, is het nog steeds mogelijk, en die programma’ s kunnen profiteren van Rust ‘ s garanties over veiligheid. Een goed voorbeeld is de standaardbibliotheek Mutex klasse: in Go kun je vergeten een mutex-vergrendeling te verkrijgen voordat je iets opent, maar Rust laat dat niet toe.

Go is gericht op concurrency als een eerste klas concept. Dat wil niet zeggen dat je aspecten van Go ‘ s actor oriented concurrency niet kunt vinden in Rust, maar het wordt overgelaten als een oefening aan de programmeur.
– Dave Cheney

veiligheid

We zagen eerder dat zowel Go Als Rust op verschillende manieren proberen een grote klasse van veelvoorkomende programmeerfouten te voorkomen, die te maken hebben met geheugenbeheer. Maar vooral Rust doet er alles aan om ervoor te zorgen dat je niet iets onveiligs kunt doen dat je niet van plan was.

Rust ‘ s zeer strikte en pedantische compiler controleert elke variabele die u gebruikt en elk geheugenadres waarnaar u verwijst. Het vermijdt mogelijke data Race Voorwaarden en informeert u over ongedefinieerd gedrag. Concurrency en geheugen veiligheidsproblemen zijn fundamenteel onmogelijk om in de veilige subset van Rust.
– waarom roest?

Dit maakt programmeren in Rust een andere ervaring dan bijna alle andere talen, en het kan in het begin een uitdaging zijn. Maar voor veel mensen is het harde werk de moeite waard.

voor mij is het belangrijkste voordeel van Rust een gevoel dat de compiler mijn rug heeft en geen enkele bug zal doorlaten die het zou kunnen detecteren (serieus, het voelt soms als magie).
– Grzegorz Nosek

veel talen, waaronder Go, hebben faciliteiten om programmeurs te helpen fouten te voorkomen, maar Rust brengt dit naar een nieuw niveau, zodat potentieel onjuiste programma ‘ s niet eens compileren.

met Rust heeft de bibliotheekprogrammeur veel tools om te voorkomen dat gebruikers fouten maken. Rust geeft ons de mogelijkheid om te zeggen dat we > eigen> een specifiek stuk gegevens; het is niet mogelijk voor iets anders om eigendom te claimen, dus we weten dat niets anders in staat zal zijn om het te wijzigen. Ik kan me geen moment voorstellen dat ik ooit zoveel tools heb gekregen om toevallig misbruik te voorkomen. Het is een heerlijk gevoel.
– Sam Rose

” Fighting with the borrowed checker ” is een veel voorkomend syndroom voor nieuwe Rust-programmeurs, maar in de meeste gevallen zijn de problemen die het vindt echte bugs (of op zijn minst potentiële bugs) in uw code. Het kan je dwingen om fundamenteel re-architect uw programma om te voorkomen dat in deze problemen; en dat is een goede zaak, wanneer juistheid en betrouwbaarheid zijn uw topprioriteit. Wat is het nut van een taal die de manier waarop je programmeert niet verandert? De lessen die Rust leert over veiligheid kunnen ook nuttig zijn als je in andere talen werkt.

Als u Rust kiest, hebt u meestal de garanties nodig die de taal biedt: veiligheid tegen null pointers en data races, voorspelbaar runtime gedrag, en totale controle over de hardware. Als u geen van deze functies nodig heeft, kan Rust een slechte keuze zijn voor uw volgende project. Dat komt omdat deze garanties komen met een kosten: ramp-up tijd. Je moet slechte gewoonten afleren en nieuwe concepten leren. De kans is groot dat je veel met de borrowse checker zult vechten als je begint.
– Matthias Endler

hoe uitdagend je het programmeermodel van Rust vindt hangt waarschijnlijk af van welke eerdere ervaring Je hebt in andere talen. Python of Ruby programmeurs kunnen vinden het beperkend; anderen zullen blij zijn.

Als u een C-of C++ – programmeur bent die weken heeft doorgebracht met het opsporen van geheugenveiligheidsfouten in die talen, zult u Rust echt waarderen. “Fighting the borrow checker “wordt” de compiler kan dat detecteren? Cool!”
—Grzegorz Nosek

Scale

de huidige serverprogramma ‘ s bestaan uit tientallen miljoenen regels code, worden door honderden of zelfs duizenden programmeurs bewerkt en worden letterlijk elke dag bijgewerkt. Go is ontworpen en ontwikkeld om het werken in deze omgeving productiever te maken. Go ‘ s ontwerpoverwegingen omvatten rigoureus afhankelijkheidsbeheer, het aanpassingsvermogen van softwarearchitectuur naarmate systemen groeien en robuustheid over de grenzen heen tussen componenten.
– Rob Pike

wanneer u zelf of in kleine teams aan een probleem werkt, is de keuze van een eenvoudige taal of een rijke taal een kwestie van voorkeur. Maar naarmate de software groter en complexer wordt, en de teams groter worden, beginnen de verschillen echt zichtbaar te worden. Voor grote toepassingen en gedistribueerde systemen is de snelheid van uitvoering minder belangrijk dan de snelheid van ontwikkeling: een doelbewust minimale taal als Go vermindert de oprit-up tijd voor nieuwe ontwikkelaars, en maakt het gemakkelijker voor hen om te werken met een grote codebase.

met Go is het makkelijker als een junior ontwikkelaar om productiever te zijn, en moeilijker als een mid-level Ontwikkelaar om broze abstracties te introduceren die later problemen zullen veroorzaken. Om deze redenen, Rust is minder dwingend dan gaan voor enterprise software ontwikkeling.
– Loris Cro

als het gaat om software ontwikkeling in de grote, clear is beter dan clever. Go ‘ s beperkingen maken het eigenlijk meer geschikt voor bedrijven en grote organisaties dan complexere en krachtigere talen zoals Rust.

de verschillen

hoewel Rust en Go zowel populaire, moderne, veelgebruikte talen zijn, zijn ze niet echt concurrenten, in de zin dat ze zich bewust richten op heel verschillende use cases. Go ‘s hele benadering van programmeren is radicaal anders dan Rust’ s, en elke taal zal geschikt zijn voor sommige mensen, terwijl irriteren anderen. Dat is absoluut prima, en als zowel Rust en Go min of meer dezelfde dingen zouden doen op min of meer dezelfde manier, zouden we niet echt twee verschillende talen nodig hebben.

dus kunnen we een idee krijgen van de respectieve aard van Rust en gaan door het vinden van kwesties waarop ze nemen drastisch verschillende benaderingen? Laten we dat uitzoeken.

Garbage collection

“to garbage-collect, or not to garbage-collect” is een van die vragen die geen juist antwoord heeft. Garbage collection, en automatisch geheugenbeheer in het algemeen, maakt het snel en gemakkelijk om betrouwbare, efficiënte programma ‘ s te ontwikkelen, en voor sommige mensen dat maakt het essentieel. Maar anderen zeggen dat garbage collection, met zijn prestaties overhead en stop-the-world pauzes, zorgt ervoor dat programma ‘ s zich onvoorspelbaar gedragen tijdens run-time, en introduceert onaanvaardbare latency. Het debat gaat door.

Go is een heel andere taal dan Rust. Hoewel beide vaag kunnen worden omschreven als systeemtalen of vervangingen voor C, hebben ze verschillende doelen en toepassingen, stijlen van taalontwerp en prioriteiten. Garbage collection is echt een enorme differentiërer. Het hebben van GC in Go maakt de taal veel eenvoudiger en kleiner, en gemakkelijk te redeneren over.

het niet hebben van GC in Rust maakt het erg snel (vooral als je gegarandeerde latency nodig hebt, niet alleen een hoge doorvoer) en maakt functies en programmeerpatronen mogelijk die niet mogelijk zijn in Go (of tenminste niet zonder prestatie in te leveren).
– PingCAP

dicht bij het metaal

De geschiedenis van computerprogrammeren is een verhaal van steeds geavanceerdere abstracties die de programmeur problemen laten oplossen zonder zich al te veel zorgen te maken over hoe de onderliggende machine eigenlijk werkt. Dat maakt programma ‘ s makkelijker om te schrijven en misschien meer draagbaar. Maar voor veel programma ‘ s zijn toegang tot de hardware, en nauwkeurige controle over hoe het programma wordt uitgevoerd, belangrijker. Rust wil programmeurs “dichter bij het metaal” laten komen, met meer controle, maar abstraheert de architectonische details om programmeurs dichter bij het probleem te laten komen.

beide talen hebben een ander bereik. Golang schijnt voor het schrijven van microservices en voor typische” DevOps ” taken, maar het is niet een Systemen programmeertaal. Rust is sterker voor taken waar concurrency, veiligheid en / of prestaties belangrijk zijn; maar het heeft een steilere leercurve dan Go.
—Matthias Endler

moet sneller gaan

Ik heb elders geschreven dat prestaties minder belangrijk zijn dan leesbaarheid voor de meeste programma ‘ s. Maar als prestaties er toe doen, doet het er echt toe. Rust maakt een aantal design trade-offs om de best mogelijke uitvoeringssnelheid te bereiken. In tegenstelling, Go is meer bezorgd over eenvoud, en het is bereid om een aantal (run-time) prestaties op te offeren voor het. Maar Go ‘ s bouwsnelheid is onverslaanbaar, en dat is belangrijk voor grote codebases.

Rust is sneller dan Go. In de bovenstaande benchmarks was roest sneller, en in sommige gevallen een orde van grootte sneller. Maar voordat je ervoor kiest om alles in Rust te schrijven, bedenk dan dat Go niet zo ver achter lag in veel van die benchmarks, en het is nog steeds veel sneller dan de wil van Java, C#, JavaScript, Python en ga zo maar door.

Als u top-of-the-line prestaties nodig hebt, bent u voor op het spel door een van deze twee talen te kiezen. Als u een webservice bouwt die hoge belasting afhandelt, die u zowel verticaal als horizontaal wilt kunnen schalen, dan past elke taal perfect bij u.
– Andrew Lader

juistheid

aan de andere kant kan een programma willekeurig snel zijn als het niet goed hoeft te werken. De meeste code is niet geschreven voor de lange termijn, maar het is vaak verrassend hoe lang sommige programma ‘ s kunnen blijven draaien in de productie: in sommige gevallen, vele decennia. In deze situaties is het de moeite waard om een beetje extra tijd in ontwikkeling te nemen om ervoor te zorgen dat het programma correct, betrouwbaar is en in de toekomst niet veel onderhoud nodig heeft.

mijn take: ga voor de code die morgen verzonden moet worden, roest voor de code die de komende vijf jaar onaangeroerd moet blijven.
– Grzegorz Nosek

hoewel Go en Rust goede keuzes zijn voor elk serieus project, is het een goed idee om jezelf zo goed mogelijk te informeren over elke taal en zijn kenmerken. Uiteindelijk maakt het niet uit wat iemand anders denkt: alleen jij kunt beslissen wat goed is voor jou en je team.

Als u sneller wilt ontwikkelen, misschien omdat u veel verschillende diensten moet schrijven, of omdat u een groot team van ontwikkelaars hebt, dan is Go uw taal naar keuze. Go geeft je concurrency als een eersteklas burger, en tolereert geen onveilige toegang tot het geheugen (noch roest), maar zonder u te dwingen om elk detail te beheren. Go is snel en krachtig, maar het voorkomt dat de ontwikkelaar vastloopt en richt zich in plaats daarvan op eenvoud en uniformiteit. Als aan de andere kant, wringen uit elke laatste ounce van de prestaties is een noodzaak, dan roest moet uw keuze.
– Andrew Lader

conclusie

Ik hoop dat dit artikel u ervan heeft overtuigd dat zowel Rust als Go uw serieuze aandacht verdienen. Als het al mogelijk is, moet je streven naar ten minste een niveau van ervaring in beide talen, omdat ze ongelooflijk nuttig voor u in elke tech carrière zal zijn, of zelfs als u geniet van het programmeren als een hobby. Als je alleen tijd hebt om te investeren in het leren van een taal goed, maak je definitieve beslissing niet totdat je zowel Go en Rust hebt gebruikt voor een verscheidenheid van verschillende soorten programma ‘ s, groot en klein.

en kennis van een programmeertaal is eigenlijk slechts een klein deel van een succesvolle software engineer zijn. Veruit de belangrijkste vaardigheden die je nodig hebt zijn ontwerp, engineering, architectuur, communicatie en samenwerking. Als je hierin uitblinkt, ben je een geweldige software engineer, ongeacht je taalkeuze. Gelukkig leren!

het vergelijken van Rust en Go code

Er is een geweldige website genaamd programming-idioms.org die heeft een “spiekbriefje” laat zien hoe de Rust en Go-code eruit ziet voor meer dan 200 gemeenschappelijke programmeertaken:

• Go vs Rust idiomen

aan de slag

Als u geïnteresseerd bent in het leren programmeren met Rust en Go, zijn hier een paar bronnen die u wellicht nuttig kunt vinden.

Naar

• Installeren Ga
• Ga tutorials door Bitveld
• Voor de Liefde van Go
• Een Tour van Go
• Ga Door Voorbeeld
• De Speeltuin Gaan
• Awesome Gaan

Rust

• Installeren Roest
• A Gentle Introduction to Roest
• De Roest programmeertaal
• Roest boeken
• Rust Door Voorbeeld
• De Roest Speeltuin
• Honderd Roest Binaire bestanden

Colofon

ik ben niet jong genoeg om alles te weten, zoals het gezegde gaat, dus ik ben heel dankbaar dat een aantal van de onderscheiden Gophers en Rustaceans wie nam de tijd om dit stuk te herzien en te corrigeren, evenals het verstrekken van een aantal echt nuttige suggesties. Mijn speciale dank gaat uit naar Bill Kennedy, Grzegorz Nosek, Sam Rose, Jack Mott, Steve Klabnik, MN Mark, Ola Nordstrom, Levi Lovelock, Emile Pels, Sebastian Lauwers, Carl Lerche, en alle anderen die hebben bijgedragen. Je zou de indruk krijgen van het lezen van online hot neemt dat de roest en gaan gemeenschappen niet met elkaar opschieten. Niets kan verder van de waarheid zijn, in mijn ervaring; we hadden zeer beschaafde en vruchtbare discussies over het ontwerpartikel, en het heeft een groot verschil gemaakt voor het eindproduct. Nogmaals bedankt.