Wann man Rust und wann Go verwenden sollte

Auf Anhieb gibt es klare Unterschiede zwischen Go und Rust. Go hat einen stärkeren Fokus auf den Aufbau von Web-APIs und kleinen Diensten, die endlos skalieren können, vor allem mit der Macht der Goroutinen. Letzteres ist auch mit Rust möglich, aber vom Standpunkt der Entwicklererfahrung aus ist es viel schwieriger.

Rust eignet sich gut für die Verarbeitung großer Datenmengen und andere CPU-intensive Operationen, wie die Ausführung von Algorithmen. Dies ist der größte Vorteil von Rust gegenüber Go. Projekte, die eine hohe Leistung erfordern, sind im Allgemeinen besser für Rust geeignet.

In diesem Tutorial werden wir Go und Rust vergleichen und gegenüberstellen, indem wir jede Programmiersprache in Bezug auf Leistung, Gleichzeitigkeit, Speicherverwaltung und die allgemeine Erfahrung für Entwickler bewerten. Außerdem geben wir einen Überblick über diese Elemente, damit Sie auf einen Blick die richtige Sprache für Ihr Projekt auswählen können.

Wenn Sie gerade erst mit Rust anfangen, ist es vielleicht eine gute Idee, diesen Leitfaden für Einsteiger zu lesen, bevor Sie weitermachen.

Wenn du alles verstanden hast, lass uns eintauchen!

Leistung

Ursprünglich von Google-Ingenieuren entwickelt, wurde Go 2009 der Öffentlichkeit vorgestellt. Es wurde entwickelt, um eine Alternative zu C++ zu bieten, die einfacher zu erlernen und zu programmieren ist und für die Ausführung auf Multicore-CPUs optimiert wurde.

Seitdem ist Go ideal für Entwickler, die die Vorteile der Gleichzeitigkeit nutzen möchten, die die Sprache bietet. Die Sprache bietet Goroutinen, die es ermöglichen, Funktionen als Unterprozesse auszuführen.

Ein großer Vorteil von Go ist, wie einfach man Goroutinen verwenden kann. Durch einfaches Hinzufügen der go-Syntax zu einer Funktion wird diese als Unterprozess ausgeführt. Das Gleichzeitigkeitsmodell von Go ermöglicht es, Arbeitslasten über mehrere CPU-Kerne zu verteilen, was es zu einer sehr effizienten Sprache macht.

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

Trotz der Unterstützung von Multicore-CPUs schafft es Rust immer noch, Go zu übertreffen. Rust ist effizienter bei der Ausführung von Algorithmen und ressourcenintensiven Operationen. Das Benchmarks Game vergleicht Rust und Go für verschiedene Algorithmen, wie z.B. binäre Bäume. Bei allen getesteten Algorithmen war Rust mindestens 30 Prozent schneller, bei Binärbaumberechnungen sogar bis zu 1.000 Prozent. Eine Studie von Bitbucket zeigt ähnliche Ergebnisse, bei denen Rust gleichauf mit C++ liegt.

(Quelle: Benchmarks Game)

Gleichzeitigkeit

Wie oben erwähnt, unterstützt Go Gleichzeitigkeit. Nehmen wir zum Beispiel an, Sie betreiben einen Webserver, der API-Anfragen verarbeitet. Sie können Go’s goroutines verwenden, um jede Anfrage als Subprozess auszuführen und so die Effizienz zu maximieren, indem Sie die Aufgaben auf alle verfügbaren CPU-Kerne verteilen.

Goroutines sind Teil von Go’s eingebauten Funktionen, während Rust nur eine native async/await-Syntax erhalten hat, um Gleichzeitigkeit zu unterstützen. Daher geht der Vorteil der Entwicklererfahrung bei der Gleichzeitigkeit an Go. Allerdings ist Rust viel besser darin, Speichersicherheit zu garantieren.

Hier ist ein Beispiel für vereinfachte Threads 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!");}

Gleichzeitigkeit war schon immer ein heikles Problem für Entwickler. Es ist keine leichte Aufgabe, speichersichere Gleichzeitigkeit zu garantieren, ohne die Entwicklererfahrung zu beeinträchtigen. Dieser extreme Sicherheitsfokus führte jedoch zur Schaffung von beweisbar korrekter Gleichzeitigkeit. Rust experimentierte mit dem Konzept der Eigentümerschaft, um den unaufgeforderten Zugriff auf Ressourcen zu verhindern, um Speicher-Sicherheitsfehler zu vermeiden.

Rust bietet vier verschiedene Parallelitätsparadigmen, um Ihnen zu helfen, häufige Speicher-Sicherheitsfallen zu vermeiden. Wir werden uns zwei gängige Paradigmen genauer ansehen: Channel und Lock.

Channel

Ein Channel hilft, eine Nachricht von einem Thread zu einem anderen zu übertragen. Während dieses Konzept auch für Go existiert, erlaubt es Rust, einen Zeiger von einem Thread zu einem anderen zu übertragen, um Rennbedingungen für Ressourcen zu vermeiden. Durch die Übergabe von Zeigern kann Rust eine Thread-Isolation für Kanäle erzwingen. Auch hier zeigt Rust seine Besessenheit von Speichersicherheit in Bezug auf sein Gleichzeitigkeitsmodell.

Lock

Daten sind nur zugänglich, wenn das Lock gehalten wird. Rust setzt auf das Prinzip des Sperrens von Daten anstelle des Codierens, das in Programmiersprachen wie Java häufig anzutreffen ist.

Weitere Details zum Konzept der Eigentümerschaft und zu allen Gleichzeitigkeitsparadigmen finden Sie in „Fearless Concurrency with Rust“

Speichersicherheit

Das frühere Konzept der Eigentümerschaft ist eines der Hauptargumente von Rust. Rust hebt die Typsicherheit, die auch wichtig ist, um speichersichere Gleichzeitigkeit zu ermöglichen, auf die nächste Stufe.“

Im Bitbucket-Blog heißt es: „Der sehr strenge und pedantische Compiler von Rust überprüft jede Variable, die Sie verwenden, und jede Speicheradresse, auf die Sie verweisen. Er vermeidet mögliche Daten-Race-Bedingungen und informiert Sie über undefiniertes Verhalten“

Das bedeutet, dass Sie aufgrund der extremen Besessenheit von Rust mit Speichersicherheit nicht mit einem Pufferüberlauf oder einer Race Condition enden werden. Allerdings hat das auch seine Nachteile. Zum Beispiel muss man sich beim Schreiben von Code über die Prinzipien der Speicherzuweisung im Klaren sein. Es ist nicht einfach, immer auf die Speichersicherheit zu achten.

Erfahrung des Entwicklers

Zunächst einmal sollten wir uns die Lernkurve der einzelnen Sprachen ansehen. Go wurde mit Blick auf Einfachheit entwickelt. Entwickler bezeichnen es oft als „langweilige“ Sprache, was bedeutet, dass Go aufgrund seiner begrenzten Anzahl an eingebauten Funktionen leicht zu erlernen ist.

Außerdem bietet Go eine einfachere Alternative zu C++, indem es Aspekte wie Speichersicherheit und Speicherzuweisung ausblendet. Rust verfolgt einen anderen Ansatz und zwingt Sie dazu, über Konzepte wie Speichersicherheit nachzudenken. Das Konzept der Eigentümerschaft und die Möglichkeit, Zeiger zu übergeben, machen Rust zu einer weniger attraktiven Lernoption. Wenn Sie ständig über Speichersicherheit nachdenken müssen, sind Sie weniger produktiv und Ihr Code wird zwangsläufig komplizierter sein.

Die Lernkurve für Rust ist im Vergleich zu Go ziemlich steil. Es ist jedoch erwähnenswert, dass Go eine steilere Lernkurve hat als dynamischere Sprachen wie Python und JavaScript.

Wann sollte man Go verwenden

Go eignet sich für eine Vielzahl von Anwendungsfällen, was es zu einer großartigen Alternative zu Node.js für die Erstellung von Web-APIs macht. Wie Loris Cro anmerkt, „ist das Gleichzeitigkeitsmodell von Go eine gute Lösung für serverseitige Anwendungen, die mehrere unabhängige Anfragen verarbeiten müssen“. Genau aus diesem Grund bietet Go Goroutinen.

Darüber hinaus verfügt Go über integrierte Unterstützung für das HTTP-Webprotokoll. Mit der eingebauten HTTP-Unterstützung kann man schnell eine kleine API entwerfen und sie als Microservice betreiben. Daher passt Go gut zur Microservices-Architektur und erfüllt die Bedürfnisse von API-Entwicklern.

Zusammenfassend lässt sich sagen, dass Go gut geeignet ist, wenn Sie Wert auf eine schnelle Entwicklung legen und die Einfachheit der Syntax der Leistung vorziehen. Darüber hinaus bietet Go eine bessere Lesbarkeit des Codes, was ein wichtiges Kriterium für große Entwicklungsteams ist.

Wählen Sie Go, wenn:

• Sie Wert auf Einfachheit und Lesbarkeit legen
• Sie eine einfache Syntax wollen, um schnell Code zu schreiben
• Sie eine flexiblere Sprache verwenden wollen, die Web-Entwicklung unterstützt

Wann sollten Sie Rust verwenden

Rust ist eine gute Wahl, wenn es auf Leistung ankommt, z. B. wenn Sie große Datenmengen verarbeiten. Darüber hinaus bietet Rust eine fein abgestufte Kontrolle darüber, wie sich Threads verhalten und wie Ressourcen zwischen Threads geteilt werden.

Auf der anderen Seite ist Rust mit einer steilen Lernkurve verbunden und verlangsamt die Entwicklungsgeschwindigkeit aufgrund der zusätzlichen Komplexität der Speichersicherheit. Das ist nicht unbedingt ein Nachteil; Rust garantiert auch, dass man keine Memory Safety Bugs findet, da der Compiler jeden einzelnen Datenzeiger überprüft. Für komplexe Systeme kann diese Garantie sehr nützlich sein.

Wählen Sie Rust, wenn:

• Sie Wert auf Leistung legen
• Sie feinkörnige Kontrolle über Threads wünschen
• Sie Speichersicherheit der Einfachheit vorziehen

Go vs. Rust: Meine ehrliche Meinung

Fangen wir damit an, die Gemeinsamkeiten hervorzuheben. Sowohl Go als auch Rust sind quelloffen und wurden entwickelt, um die Microservices-Architektur und parallele Computing-Umgebungen zu unterstützen. Beide optimieren die Nutzung der verfügbaren CPU-Kerne durch Parallelität.

Aber welche Sprache ist letztendlich die beste?

Es gibt viele Möglichkeiten, diese Frage anzugehen. Ich würde empfehlen, darüber nachzudenken, welche Art von Anwendung Sie erstellen wollen. Go eignet sich gut für die Erstellung von Webanwendungen und APIs, die die Vorteile der eingebauten Gleichzeitigkeitsfunktionen nutzen und gleichzeitig die Microservices-Architektur unterstützen.

Sie können auch Rust verwenden, um eine Web-API zu entwickeln, aber es wurde nicht für diesen Anwendungsfall entwickelt. Der Fokus von Rust auf Speichersicherheit erhöht die Komplexität und die Entwicklungszeit, insbesondere für eine relativ einfache Web-API. Die größere Kontrolle, die Sie über Ihren Code haben, ermöglicht es Ihnen jedoch, optimierteren, speichereffizienteren und performanteren Code zu schreiben.

Um es so einfach wie möglich auszudrücken, ist die Debatte zwischen Go und Rust in Wirklichkeit eine Frage der Einfachheit und der Sicherheit.

Für weitere Perspektiven lesen Sie „Die Wahl zwischen Go und Rust“.