Bitfield Consulting

Rust och Go är båda fantastiska

först är det verkligen viktigt att säga att både Go och Rust är helt utmärkta programmeringsspråk. De är moderna, kraftfulla, allmänt antagna och erbjuder utmärkt prestanda. Du kanske har läst artiklar och blogginlägg som syftar till att övertyga dig om att Go är bättre än Rust, eller vice versa. Men det är verkligen ingen mening; varje programmeringsspråk representerar en uppsättning av kompromisser. Varje språk är optimerat för olika saker, så ditt val av språk bör bestämmas av vad som passar dig och de problem du vill lösa med det.

i den här artikeln ska jag försöka ge en kort översikt över var jag tycker att Go är det perfekta valet, och där jag tycker att Rust är ett bättre alternativ. Helst bör du dock ha en fungerande kännedom om båda språken. Medan de är väldigt olika i syntax och stil, är både Rust och Go förstklassiga verktyg för att bygga programvara. Med det sagt, låt oss titta närmare på de två språken.

likheterna

Rust and Go har mycket gemensamt, vilket är en anledning till att du ofta hör dem nämnas tillsammans. Vilka är de gemensamma målen för båda språken?

Rust är ett statiskt typat multi-paradigm programmeringsspråk på låg nivå som fokuserar på säkerhet och prestanda.
—Gints Dreimanis

Go är ett programmeringsspråk med öppen källkod som gör det enkelt att bygga enkel, pålitlig och effektiv programvara.
—Golang.org

Minnessäkerhet

både Go och Rust tillhör gruppen moderna programmeringsspråk vars prioritet är minnessäkerhet. Det har blivit tydligt under många decennier av att använda äldre språk som C och C++ att en av de största orsakerna till buggar och säkerhetsproblem är att komma åt minnet osäkert eller felaktigt. Rust and Go hanterar detta problem på olika sätt, men båda syftar till att vara smartare och säkrare än andra språk om hantering av minne och för att hjälpa dig att skriva korrekta och presterande program.

snabba, kompakta körbara

de är båda kompilerade språk, vilket innebär att dina program översätts direkt till körbar maskinkod, så att du kan distribuera ditt program som en enda binär fil; till skillnad från tolkade språk som Python och Ruby behöver du inte distribuera en tolk och massor av bibliotek och beroenden tillsammans med ditt program, vilket är ett stort plus. Detta gör också både Rust och Go-Program extremt snabba jämfört med tolkade språk.

allmänna språk

Rust och Go är också både kraftfulla, skalbara allmänna programmeringsspråk, som du kan använda för att utveckla alla typer av modern programvara, från webbapplikationer till distribuerade mikrotjänster eller från inbäddade mikrokontroller till mobilappar. Båda har utmärkta standardbibliotek och ett blomstrande ekosystem från tredje part, samt bra kommersiellt stöd och en stor användarbas. De har båda funnits i många år, och kommer att fortsätta att användas i stor utsträckning i många år framöver. Att lära sig antingen Go eller Rust idag kommer att vara en bra investering av din tid och ansträngning.

pragmatisk programmeringsstil

varken är främst funktionella språk (som Scala eller Elixir, till exempel), och inte heller är uteslutande objektorienterade (som Java och C#). Istället, medan både Go och Rust har funktioner som är förknippade med funktionell och objektorienterad programmering, är de pragmatiska språk som syftar till att lösa problem på vilket sätt som helst, snarare än att tvinga dig till ett visst sätt att göra saker. (Om du gillar den funktionella stilen för programmering, hittar du dock mycket fler faciliteter för det i Rust, eftersom Rust har mycket fler faciliteter än Go i allmänhet.)

Vi kan diskutera om vad ett “objektorienterat” språk är, men det är rättvist att säga att stilen för objektorienterad programmering som C++, Java eller C#-användare förväntar sig inte finns i antingen Go eller Rust.
—Jack Mott

utveckling i skala

både Rust och Go har några användbara funktioner som gör dem lämpliga för programmering i det stora, oavsett om det betyder stora lag eller stora kodbaser eller båda.

till exempel, medan C-programmerare har argumenterat i flera år om var de ska sätta sina parenteser och om koden ska vara indragen med flikar eller mellanslag, eliminerar både Rust och Go sådana problem helt genom att använda ett standardformateringsverktyg (gofmt för Go, rustfmt för Rust) som omskriver din kod automatiskt med den kanoniska stilen. Det är inte så att den här stilen är så underbar i sig: det är standardiseringen som Rust and Go-programmerare uppskattar.

> gofmtstil är ingen favorit, men gofmt är allas favorit.

—Rob Pike

ett annat område där båda språken får höga poäng finns i byggledningen. Båda har utmärkta, inbyggda, högpresterande standardbyggnads-och beroendehanteringsverktyg; inte mer brottas med komplexa tredjepartssystem och måste lära sig en ny varje par år.

bygga Go och Rust kod, efter att ha kommit från en Java och Ruby bakgrund i min tidiga karriär, kändes som en omöjlig vikt av mina axlar. När jag var på Google var det en lättnad att komma över en tjänst som skrevs i Go, för jag visste att det skulle vara lätt att bygga och köra. Detta har också varit sant för Rust, även om jag bara har arbetat med det i mycket mindre skala. Jag hoppas att dagarna med oändligt konfigurerbara byggsystem är döda, och språk skickas alla med sina egna specialbyggda byggverktyg som bara fungerar ur lådan.
—Sam Rose

så vad är allt väsen om?

med allt detta i åtanke, och med tanke på att båda språken är så väl utformade och kraftfulla, kanske du undrar vad alla heliga krig handlar om (jag också). Varför människor gör ett sådant väsen om ‘Go versus Rust’, komma in arga sociala medier spats och skriva långa blogginlägg om hur bara en idiot skulle använda Rust, eller att Go är inte en riktig programmeringsspråk, eller vad som helst. Det kan få dem att må bättre, men det hjälper dig inte precis, som någon som försöker bestämma vilket språk som ska användas för ditt projekt, eller som du bör lära dig att fördjupa din programmeringskarriär. En klok person gör inte viktiga val baserat på vem som ropar högst.

Låt oss fortsätta vår vuxna diskussion nu genom att titta på några områden där en rimlig person kanske föredrar ett språk framför det andra.

prestanda

Vi har sagt att både Go och Rust producerar extremt snabba program eftersom de sammanställs till inbyggd maskinkod, utan att behöva gå igenom en tolk eller virtuell maskin. Rusts prestanda är dock särskilt enastående. Det är jämförbart med C och C++, som ofta betraktas som de högsta prestanda kompilerade språken, men till skillnad från dessa äldre språk erbjuder det också minnessäkerhet och samtidighetssäkerhet till väsentligen ingen kostnad i exekveringshastighet. Rust låter dig också skapa komplexa abstraktioner utan att betala en prestationsstraff vid körning.

Som jämförelse, även om Go-program också fungerar extremt bra, är Go främst utformat för snabb utveckling (inklusive sammanställning), snarare än snabb körning. Go-kompilatorn spenderar inte mycket tid på att försöka generera den mest effektiva möjliga maskinkoden; det bryr sig mer om att snabbt sammanställa mycket kod. Så rost kommer vanligtvis att slå gå i körtidsriktmärken.

Rusts körtidsprestanda är också konsekvent och förutsägbar, eftersom den inte använder sophämtning. Go ‘ s garbage collector är mycket effektiv, och den är optimerad för att göra sin stop-the-world-paus så kort som möjligt (och blir kortare med varje ny Go-release). Men sophämtning introducerar oundvikligen viss oförutsägbarhet i hur program beter sig, vilket kan vara ett allvarligt problem i vissa applikationer, till exempel inbyggda system.

eftersom Rust syftar till att ge programmeraren fullständig kontroll över den underliggande hårdvaran är det möjligt att optimera Rust-program för att vara ganska nära maskinens maximala teoretiska prestanda. Detta gör Rust till ett utmärkt val för områden där exekveringshastigheten slår alla andra överväganden, till exempel spelprogrammering, operativsystemkärnor, webbläsarkomponenter och realtidsstyrsystem.

enkelhet

det spelar ingen roll hur snabbt ett programmeringsspråk är om ingen kan räkna ut hur man använder det. Go var medvetet tänkt som en reaktion mot den ständigt växande komplexiteten hos språk som C++; den har väldigt lite syntax, väldigt få nyckelord och faktiskt få funktioner. Det betyder att det inte tar lång tid att lära sig Go-språket till den punkt där du kan skriva användbara program i det.

Go är otroligt lätt att lära sig. Jag vet att detta är en ofta tippad fördel, men jag blev verkligen förvånad över hur snabbt jag kunde vara produktiv. Tack vare språket, dokumenten och verktygen skrev jag intressant, bindande kod efter bokstavligen två dagar.
—tidiga intryck av Go från en Rostprogrammerare

nyckelordet här är enkelhet. Enkelt är inte detsamma som enkelt, säkert, men ett litet, enkelt språk är lättare att lära sig än ett stort, komplext. Det finns bara inte så många olika sätt att göra saker, så All välskriven Go-kod tenderar att se likadan ut. Det är lätt att bara dyka in i en okänd tjänst och förstå vad den gör.

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

(I Code Club-serien gör jag exakt det: välj Go-projekt semi-slumpmässigt från GitHub och utforska dem med en grupp Go-nybörjare, för att se hur mycket av koden vi kan förstå. Det visar sig alltid vara mer än vi förväntade oss!)

även om kärnspråket är litet är Go: s standardbibliotek mycket kraftfullt. Det betyder att din inlärningskurva också måste inkludera de delar av standardbiblioteket som du behöver, inte bara gå syntax. Å andra sidan innebär att flytta funktionalitet från språket och in i standardbiblioteket att du bara kan fokusera på att lära dig de bibliotek som är relevanta för dig just nu.

Go är också utformad för mjukvaruutveckling i stor skala, med stora kodbaser och stora team. I dessa situationer är det viktigt att nya utvecklare kan komma igång så snabbt som möjligt.

med Go får du saker gjorda—snabbt. Go är ett av de mest produktiva språk jag någonsin har arbetat med. Mantrat är: >lös verkliga problem idag>.
—Matthias Endler

funktioner

Rust stöder mer komplexitet än flera andra programmeringsspråk, därför kan du uppnå mer med det. Till exempel stöder den generika.
—Devathon

Rust är speciellt utformad för att innehålla massor av kraftfulla och användbara funktioner för att hjälpa programmerare att göra det mesta med minst kod. Till exempel kan Rusts match funktionen skriva flexibel, uttrycksfull logik ganska kortfattat:

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

eftersom Rust gör mycket betyder det att det finns mycket att lära sig, särskilt i början. Men det är okej: det finns mycket att lära sig i C++ eller Java, och du får inte de avancerade funktionerna som följer med Rust, som minnessäkerhet. Att kritisera Rust för att vara ett komplext språk saknar poängen: det är utformat för att vara uttrycksfullt, vilket innebär att ha många funktioner, och i många situationer är det vad du vill ha från ett programmeringsspråk. Det finns en inlärningskurva, säkert, men när du är igång med det, kommer du att bli bra.

Rust tävlar om mindshare med C++ och D för programmerare som är beredda att acceptera mer komplex syntax och semantik (och förmodligen högre läsbarhetskostnader) i utbyte mot maximal möjlig prestanda.
—Dave Cheney

samtidighet

de flesta språk har någon form av stöd för samtidig programmering (gör flera saker samtidigt), men Go designades för det här jobbet från grunden. Istället för att använda operativsystemtrådar ger Go ett lätt alternativ: goroutines. Varje goroutine är en oberoende exekverande Go-funktion, som go-Schemaläggaren kommer att kartlägga till en av OS-trådarna under dess kontroll. Detta innebär att Schemaläggaren mycket effektivt kan hantera ett stort antal samtidiga goroutiner, med endast ett begränsat antal OS-trådar.

följaktligen kan du köra miljontals samtidiga goroutines i ett enda program utan att skapa allvarliga prestandaproblem. Det gör Go till det perfekta valet för storskaliga samtidiga applikationer som webbservrar och mikrotjänster.

Go har också snabba, säkra och effektiva sätt för goroutines att kommunicera och dela data med hjälp av kanaler. Go: s samtidighetsstöd känns väl utformat och ett nöje att använda. Att resonera om samtidiga program är svårt i allmänhet, och att bygga pålitliga, korrekta samtidiga program är en utmaning på alla språk. Eftersom det byggdes in i språket från början, men istället för att vara en eftertanke, är samtidig programmering I Go ungefär lika enkel och väl integrerad som det rimligen kan vara.

Go gör det väldigt enkelt att bygga ett snyggt faktorerat program som drar full nytta av samtidighet samtidigt som det distribueras som en uppsättning mikrotjänster. Rost kan göra dessa saker också, men det är förmodligen lite tuffare. I vissa avseenden innebär Rusts besatthet med att förhindra minnesrelaterade säkerhetsproblem att programmerare måste gå ut ur deras sätt att utföra uppgifter som skulle vara enklare på andra språk, inklusive Go.
—Sonya Koptyev

samtidshistorien i Rust är väldigt ny, i jämförelse, och stabiliserar fortfarande, men den är under mycket aktiv utveckling, så titta på detta utrymme. Till exempel ger Rusts rayon-bibliotek ett mycket elegant och lätt sätt att förvandla sekventiella beräkningar till parallella.

att ha lättviktssyntax för att leka Go-rutiner och använda kanaler är riktigt trevligt. Det visar verkligen syntaxens kraft att sådana små detaljer gör att samtidig programmering känns så mycket trevligare än på andra språk.
—tidiga intryck av Go från en Rust-programmerare

även om det kan vara lite mindre enkelt att implementera samtidiga program i Rust, är det fortfarande möjligt, och dessa program kan dra nytta av Rusts garantier om säkerhet. Ett bra exempel är standardbiblioteketsMutex klass: I Go kan du glömma att få ett mutex-lås innan du öppnar något, men Rust låter dig inte göra det.

Go fokuserar på samtidighet som ett förstklassigt koncept. Det är inte att säga att du inte kan hitta aspekter av Go: s skådespelareorienterade samtidighet i Rust, men det lämnas som en övning för programmeraren.
—Dave Cheney

säkerhet

vi såg tidigare att både Go och Rust syftar på olika sätt för att förhindra en stor klass av vanliga programmeringsfel att göra med minneshantering. Men rost i synnerhet sträcker sig mycket för att säkerställa att du inte kan göra något osäkert som du inte menade att göra.

Rusts mycket strikta och pedantiska kompilator kontrollerar varje variabel du använder och varje minnesadress du refererar till. Det undviker möjliga data race villkor och informerar dig om odefinierat beteende. Samtidighet och minnessäkerhetsproblem är i grunden omöjliga att komma i den säkra delmängden av Rust.
– Varför rost?

detta kommer att göra programmering i Rust till en annan upplevelse än nästan alla andra språk, och det kan vara en utmanande först. Men för många är det hårda arbetet värt det.

För mig är den viktigaste fördelen med Rust en känsla av att kompilatorn har min rygg och inte släpper igenom någon bugg som den eventuellt kan upptäcka (allvarligt känns det som magi ibland).
– Grzegorz Nosek

många språk, inklusive Go, har faciliteter för att hjälpa programmerare att undvika misstag, men Rust tar detta till en ny nivå, så att potentiellt felaktiga program inte ens kompilerar.

med Rust har biblioteksprogrammeraren många verktyg för att förhindra att användarna gör misstag. Rust ger oss möjligheten att säga att vi > äger> en specifik datadel; det är inte möjligt för något annat att hävda ägande, så vi vet att inget annat kommer att kunna ändra det. Jag kan inte tänka mig en tid jag någonsin har fått så många verktyg för att förhindra oavsiktlig missbruk tidigare. Det är en underbar känsla.
—Sam Rose

” Fighting with the borrow checker ” är ett vanligt syndrom för nya Rust-programmerare, men i de flesta fall är problemen som den hittar äkta buggar (eller åtminstone potentiella buggar) i din kod. Det kan tvinga dig att fundamentalt re-arkitekt ditt program för att undvika att köra in i dessa frågor; och det är en bra sak, när korrekthet och tillförlitlighet är din högsta prioritet. Vad är poängen med ett språk som inte förändrar hur du programmerar? De lärdomar som Rust lär om säkerhet kan vara användbara när du arbetar på andra språk också.

om du väljer Rust behöver du vanligtvis de garantier som språket ger: säkerhet mot nollpekare och datalopp, förutsägbart körtidsbeteende och total kontroll över hårdvaran. Om du inte behöver någon av dessa funktioner kan Rust vara ett dåligt val för ditt nästa projekt. Det beror på att dessa garantier kommer med en kostnad: ramp-up tid. Du måste lära dig dåliga vanor och lära dig nya koncept. Chansen är stor att du kommer att kämpa med lånekontrollen mycket när du börjar.
—Matthias Endler

hur utmanande du hittar Rusts programmeringsmodell beror förmodligen på vilken tidigare erfarenhet du har på andra språk. Python-eller Ruby-programmerare kan tycka att det är restriktivt; andra kommer att vara glada.

Om du är en C-eller C++ – programmerare som har spenderat veckor på att jaga minnessäkerhetsfel på dessa språk, kommer du verkligen att uppskatta rost. “Fighting the borrow checker “blir” kompilatorn kan upptäcka det? Coolt!”
—Grzegorz Nosek

skala

dagens serverprogram består av tiotals miljoner kodrader, bearbetas av hundratals eller till och med tusentals programmerare och uppdateras bokstavligen varje dag. Go designades och utvecklades för att göra arbetet i denna miljö mer produktivt. Go: s designöverväganden inkluderar rigorös beroendehantering, anpassningsförmågan hos mjukvaruarkitekturen när system växer och robusthet över gränserna mellan komponenter.
– Rob Pike

När du arbetar med ett problem själv eller i små grupper är valet av ett enkelt språk eller ett rikt språk en fråga om preferens. Men när programvaran blir större och mer komplex, och lagen blir större, börjar skillnaderna verkligen visa sig. För stora applikationer och distribuerade system är exekveringshastigheten mindre viktig än utvecklingshastigheten: ett medvetet minimalt språk som Go minskar ramptiden för nya utvecklare och gör det lättare för dem att arbeta med en stor kodbas.

med Go är det lättare som en junior utvecklare att vara mer produktiv och svårare som en mellannivåutvecklare att introducera spröda abstraktioner som kommer att orsaka problem längs linjen. Av dessa skäl är Rust mindre övertygande än Go för utveckling av företagsprogramvara.
– Loris Cro

När det gäller mjukvaruutveckling i det stora är clear bättre än smart. Go: s begränsningar gör det faktiskt mer lämpligt för företag och stora organisationer än mer komplexa och kraftfulla språk som Rust.

skillnaderna

Även om Rust och Go båda är populära, moderna, allmänt använda språk, är de inte riktigt konkurrenter, i den meningen att de medvetet riktar sig mot helt olika användningsfall. Go: s hela inställning till programmering är radikalt annorlunda än Rusts, och varje språk passar vissa människor medan de irriterar andra. Det är helt bra, och om både Rust och Go gjorde mer eller mindre samma saker på mer eller mindre samma sätt, skulle vi inte behöva två olika språk.

så kan vi få en känsla av respektive natur av rost och gå genom att hitta problem som de tar drastiskt olika tillvägagångssätt? Låt oss ta reda på det.

sophämtning

“till sophämtning eller inte sophämtning” är en av de frågor som inte har något rätt svar. Sophämtning, och automatisk minneshantering i allmänhet, gör det snabbt och enkelt att utveckla tillförlitliga, effektiva program, och för vissa människor som gör det viktigt. Men andra säger att sophämtning, med dess prestanda overhead och stop-the-world pauser, gör program beter oförutsägbart vid körning, och introducerar oacceptabel latens. Debatten mullrar på.

Go är ett helt annat språk än rost. Även om båda vagt kan beskrivas som systemspråk eller ersättare för C, de har olika mål och applikationer, stilar av språkdesign, och prioriteringar. Sophämtning är en riktigt stor differentiator. Att ha GC I Go gör språket mycket enklare och mindre, och lätt att resonera om.

att inte ha GC i Rust gör det riktigt snabbt (speciellt om du behöver garanterad latens, inte bara hög genomströmning) och möjliggör funktioner och programmeringsmönster som inte är möjliga I Go (eller åtminstone inte utan att offra prestanda).
– PingCAP

nära metallen

historien om datorprogrammering har varit en berättelse om alltmer sofistikerade abstraktioner som låter programmeraren lösa problem utan att oroa sig för mycket om hur den underliggande maskinen faktiskt fungerar. Det gör program lättare att skriva och kanske mer bärbara. Men för många program är åtkomst till hårdvaran och exakt kontroll över hur programmet körs viktigare. Rust syftar till att låta programmerare komma “närmare metallen”, med mer kontroll, men Go abstraherar bort de arkitektoniska detaljerna för att låta programmerare komma närmare problemet.

båda språken har ett annat omfång. Golang lyser för att skriva mikrotjänster och för typiska “DevOps” – uppgifter, men det är inte ett systemprogrammeringsspråk. Rost är starkare för uppgifter där samtidighet, säkerhet och/eller prestanda är viktiga; men det har en brantare inlärningskurva än Go.
—Matthias Endler

måste gå snabbare

Jag har skrivit någon annanstans att prestanda är mindre viktigt än läsbarhet för de flesta program. Men när prestanda spelar roll spelar det verkligen roll. Rust gör ett antal designavvägningar för att uppnå bästa möjliga körhastighet. Däremot är Go mer oroad över enkelhet, och det är villigt att offra lite (körtid) prestanda för det. Men Go: s bygghastighet är oslagbar, och det är viktigt för stora kodbaser.

rost är snabbare än Go. I riktmärkena ovan var rost snabbare och i vissa fall en storleksordning snabbare. Men innan du slutar välja att skriva allt i Rust, anser du att Go inte var så långt bakom det i många av dessa riktmärken, och det är fortfarande mycket snabbare än Java, C#, JavaScript, Python och så vidare.

om det du behöver är top-of-the-line prestanda, kommer du att vara före spelet att välja något av dessa två språk. Om du bygger en webbtjänst som hanterar hög belastning, som du vill kunna skala både vertikalt och horisontellt, kommer båda språken att passa dig perfekt.
—Andrew Lader

korrekthet

å andra sidan kan ett program vara godtyckligt snabbt om det inte behöver fungera korrekt. De flesta kod skrivs inte på lång sikt, men det är ofta förvånande hur länge vissa program kan hålla igång i produktionen: i vissa fall, många decennier. I dessa situationer är det värt att ta lite extra tid i utvecklingen för att se till att programmet är korrekt, pålitlig, och kommer inte att behöva en hel del underhåll i framtiden.

mitt tag: gå till koden som måste skickas imorgon, rost för koden som måste fortsätta att springa orörd under de kommande fem åren.
—Grzegorz Nosek

medan både Go och Rust är bra val för alla seriösa projekt, är det bra att göra dig så välinformerad som möjligt om varje språk och dess egenskaper. I slutändan spelar det ingen roll vad någon annan tycker: bara du kan bestämma vilket som är rätt för dig och ditt team.

Om du vill utvecklas snabbare, kanske för att du har många olika tjänster att skriva, eller om du har ett stort team av utvecklare, då Go är ditt språk val. Go ger dig samtidighet som en förstklassig medborgare och tolererar inte osäker minnesåtkomst (inte heller rost), men utan att tvinga dig att hantera varje detalj. Go är snabb och kraftfull, men det undviker bogging utvecklaren ner, fokusera istället på enkelhet och enhetlighet. Om å andra sidan, vrida ut varenda uns av prestanda är en nödvändighet, då rost bör vara ditt val.
—Andrew Lader

slutsats

Jag hoppas att den här artikeln har övertygat dig om att både rost och gå förtjänar din allvarliga övervägande. Om det är möjligt bör du sträva efter att få åtminstone en viss erfarenhet på båda språken, eftersom de kommer att vara otroligt användbara för dig i någon teknisk karriär, eller ens om du gillar programmering som en hobby. Om du bara har tid att investera i att lära dig ett språk bra, gör inte ditt slutliga beslut förrän du har använt både Go och Rust för en mängd olika typer av program, stora och små.

och kunskap om ett programmeringsspråk är egentligen bara en liten del av att vara en framgångsrik mjukvaruingenjör. De absolut viktigaste färdigheterna du behöver är design, teknik, arkitektur, kommunikation och samarbete. Om du utmärker dig på dessa kommer du att vara en bra mjukvaruingenjör oavsett ditt val av språk. Lyckligt lärande!

jämförelse av rost och Go-kod

det finns en bra webbplats som heter programming-idioms.org som har ett “fuskark” som visar hur Rust and Go-koden ser ut för över 200 vanliga programmeringsuppgifter:

• Go vs Rust idioms

komma igång

Om du är intresserad av att lära dig att programmera med Rust and Go, här är några resurser som du kan hitta till hjälp.

Go

• installera Go
• gå handledning av Bitfield
• för kärleken till Go
• en rundtur i Go
• gå med exempel
• Go Playground
• Awesome Go

rost

• installera rost
• en mild introduktion till rost
• programmeringsspråket Rust
• Rust books
• Rust genom exempel
• Rust playground
• hundra Rust binärer

bekräftelser

Jag är inte ung nog att veta allt, som ordspråket säger, så jag är väldigt tacksam för ett antal utmärkta gophers och rustaceans vem tog sig tid att granska och korrigera detta stycke, samt ge några riktigt användbara förslag. Mitt speciella tack går till Bill Kennedy, Grzegorz Nosek, Sam Rose, Jack Mott, Steve Klabnik, mn Mark, Ola Nordstrom, Levi Lovelock, Emile Pels, Sebastian Lauwers, Carl Lerche och alla andra som bidrog. Du kan få intrycket av att läsa online hot tar att rost-och Go-samhällena inte kommer överens. Ingenting kunde vara längre från sanningen, enligt min erfarenhet; vi hade mycket civiliserade och fruktbara diskussioner om utkastet till artikel, och det har gjort stor skillnad för den färdiga produkten. Tack igen.