Die Google-Mitarbeiter Ken Thompson, Robert Griesemer und Rob Pike waren unzufrieden mit bestehenden Programmiersprachen und Umgebungen für die Systemprogrammierung. Ihnen missfiel, dass Programmierung schwierig geworden war. Man musste sich entscheiden: Entweder eine Sprache für effiziente Kompilierung, effiziente Ausführung oder einfache Programmierung. Eine Sprache, die alle drei Anforderungen erfüllte, gab es nicht. Also entwarfen sie Go, um diese Lücke zu füllen.

Anders als Programmiersprachen wie Java oder Python stammt Go aus einer Zeit, als Computer bereits über mehr als einen Kern verfügten. Go ist eine statisch typisierte Programmiersprache, die zu Maschinencode kompiliert wird. Im Gegensatz zu beispielsweise Rust, einer ebenfalls relativ jungen Sprache, basiert Go nicht auf LLVM, sondern wurde von Grund auf neu entworfen.

Mit Programmiersprachen ist es wie mit allen Werkzeugen: Sie wurden irgendwann entwickelt, um Probleme da zu lösen, wo Bestehendes an seine Grenzen stieß. Im Fall von Go war das die Software-Entwicklung bei Google. Die Sprache wurde von und für Entwickler entworfen, die große Softwaresysteme bauen, warten und debuggen.

Andere Sprachen bekämen von Version zu Version neue Features, oft inspiriert von anderen Sprachen. Dadurch werden sie sich immer ähnlicher. In ECMAScript wurden mit Version 6 Klassen eingeführt, PHP 8 bekommt einen JIT-Compiler – Beispiele, die diese These belegen, gibt es genug.

Für Go habe man sich absichtlich für einen anderen Weg entschieden, so Rob Pike 2015 bei einem Talk auf der Godot. Als Analogie führt er die Relativität von Sprache an, eine Hypothese, die besagt, dass Sprache die Art, wie wir denken, beeinflusst. Ob haltbar oder nicht, im Fall von Programmiersprachen sei die Theorie plausibel. Wer eine logische Programmiersprache nutze, würde damit andere Probleme lösen und zwangsläufig anders denken als jemand, der mit einer nebenläufigen oder einer objektorientierten Sprache arbeite. Infinitesimalrechnungen löse schließlich auch keiner mithilfe von linearer Algebra. Wenn alle Programmiersprachen sich immer ähnlicher werden würden, würden alle Entwickler in der Folge dieser Entwicklung irgendwann auch alle auf die gleiche Art und Weise denken. Eigentlich wolle man doch verschiedene spezialisierte Tools für verschiedene Problemstellungen nutzen. Sprachen wie Java, JavaScript, C#, PHP oder C++ entwickeln sich weiter, indem sie neue Features implementieren. Damit gewinnen sie zwar an Funktionalität, proportional dazu aber auch an Komplexität. Das sei, als hätte man einen Werkzeugkasten mit verschiedenen Multifunktionstools, mit denen sich alles auf ähnliche Art und Weise lösen lässt, aber keines davon ist wirklich für einen spezifischen Anwendungsfall zugeschnitten, sagt Pike während des Talks.

Go unterscheidet sich also mit Absicht von anderen Programmiersprachen, die mit jedem neuen Versions-Update neue Features bekommen. Seit dem Launch von Go 1 wurden abgesehen von kleineren Anpassungen so gut wie keine neuen Features eingeführt. Zumindest keine großen. Gos Feature-Set ist fest.

Pike glaubt, neue Funktionalitäten würden die Programmiersprache nicht besser, nur größer und komplexer machen. Die Auswahl an Features, die schlussendlich Teil von Go werden sollten, orientierte sich vor allem an einer Maxime: Lesbarkeit und Einfachheit. Gibt es viele Wege, eine Sache zu lösen, müssen Entwickler sich für einen entscheiden. Diese Entscheidung muss jedes Mal, wenn ihr Code von ihnen selbst oder von anderen gelesen wird, nachvollzogen werden. Zusammengefasst: Der Code wird komplexer, je mehr Features und Auswahl es gibt. In Go wollte man sich auf das Wesentliche beschränken. Einen oder zumindest nur einige wenige statt vieler Lösungswege für ein Problem anbieten. So wird Code leichter zu verstehen, es wird einfacher, ihn zu schreiben und es wird auch einfacher, etwaige Bugs zu fixen.

Je komplizierter eine Sprache ist, desto schwieriger wird es, sie zu lernen und mit ihr zu arbeiten. Eine versatile Programmiersprache kann aber auch Spaß machen. Beide Eigenschaften – eine Sprache, die aufgrund der vielen verschiedenen Möglichkeiten, die sie bietet, Spaß macht und gleichzeitig leicht zu nutzen ist – sind nicht in einer vereinbar. Im Fall von Go fiel die Entscheidung klar zugunsten der Lesbarkeit aus. Das ist auch der Grund, warum zum Beispiel Methoden wie map() oder filter()  nicht in das Featureset der Sprache aufgenommen wurden, obwohl in der Go-Community vielfach der Wunsch danach geäußert wurde.

Bei der Auswahl der Features, die schlussendlich in Go implementiert wurden, hatten die Entwickler vor allem das Thema Langzeit-Wartung im Blick. Gerade im Kontext großer Projekte. Ein Auswahlkriterium war, dass Entwickler mit Kenntnissen in prozeduraler Programmierung und Erfahrung mit Sprachen wie C, C++ oder Java in Go geschriebenen Code lesen können sollten. Die Sprache sollte eine Basisausstattung an Features erhalten. Nicht fancy, aber zweckmäßig und so, dass die vorhandenen Features gut zusammenspielen.

Go wurde entwickelt, um Code für Google darin zu schreiben. Dafür bedacht werden mussten Faktoren wie konkrete Datentypen – integer, numbers, functions, methods, interfaces und Dinge wie Packages, Concurrency. Die Leitprinzipien bei der Entwicklung der Sprache lauteten schnelle Implementation und gutes Tooling. Das Ergebnis: eine Programmiersprache ohne viel Schnickschnack, die einfach zu nutzen ist. Der man nicht anmerkt, wie komplex die Entwicklung war. Pike selbst nannte sie eines der komplexesten Projekte, an denen er je gearbeitet habe.

Garbage-Collection ist ein gutes Beispiel für ein Feature, das unter der Oberfläche sehr komplex ist, für das es aber kein Interface in Go gibt. Über Ownership und Datenmanagement müssen Go-Programmierer sich absolut keine Gedanken machen, das macht der Garbage-Collector. Er ist so sehr im Hintergrund, dass Go in der Sprach-Spezifikation nicht einmal als garbage-collected klassifiziert wird.

Concurrency ist ein weiteres Beispiel für eine Funktionalität in Go, die unter der Oberfläche komplex und in der Handhabung relativ einfach ist. Concurrency, oder Nebenläufigkeit, bezeichnet die Möglichkeit, ein Programm in voneinander unabhängig auszuführenden Teilen zu schreiben. Die Nebenläufigkeit in Go besteht im Wesentlichen aus drei Komponenten:

• Go-routines (Ausführung)
• Channels (Kommunikation)
• select (Koordination)

Go-routines werden über das go-Keyword initialisiert:

go function(args)

Sie bestehen nur aus Keyword und Funktionsaufruf. Es gibt keine Thread-ids, keinen Completion-Status, nichts, was auf die Größe des Stacks hinweist. Andere Sprachen bieten diese Features, in Go gibt es sie – im Interesse der Einfachheit – nicht.

Nur weil Go einfach zu lesen und zu schreiben ist, heißt das nicht, dass der Code nicht dokumentiert werden muss. In Go gibt es standardisierte Vorgaben für die Dokumentation aller Funktionen und Libraries. Die Sprache warnt euch sogar, wenn ihr versucht, die Doku zu skippen. Das ist besonders cool für neue Entwickler, die so von Anfang an gezwungen werden, sich in der Dokumentation ihres Codes zu üben.

All diese Vorzüge gehen mit offenkundigen Nachteilen einher. Ein fixes Feature-Set und einfache Lesbarkeit bedeuten mehr Sicherheit und eine kürzere Einarbeitungszeit, gleichzeitig aber auch weniger Versatilität. Go wurde von Google für Google entwickelt, für Google-Entwickler ist sie deshalb die Programmiersprache der Wahl, aber außerhalb dieses Kosmos? Python ist die Sprache der Datenanalyse und -visualisierung, JavaScript die der Webentwicklung, Gos Platz außerhalb von Google ist im Moment noch nicht ganz so klar definiert.

Aber: Erstens gibt es so etwas wie die eine perfekte Programmiersprache nicht. Zweitens wurde Go explizit nicht als Allzweckwerkzeug entworfen. Drittens fällt die Wahl am Ende sowieso immer auf die Sprache, in der einige Dinge für einen bestimmten Anwendungsfall besser geeignet sind als in anderen.

Passend dazu: Go 1.14: Module sind reif für den Produktiveinsatz