Wer heute eine Anwendung in einem Container startet, sie mit Kubernetes verteilt, die Infrastruktur mit Terraform beschreibt und die Messwerte in Prometheus sammelt, arbeitet mit vier Werkzeugen, die alle in derselben Sprache geschrieben sind: Go. Kaum eine andere Programmiersprache hat die Infrastruktur des Internets im vergangenen Jahrzehnt so geprägt, ohne je im Mittelpunkt der öffentlichen Aufmerksamkeit zu stehen.

Dabei ist Go keine Sprache für Spezialisten. Sie gilt als eine der am schnellsten erlernbaren Sprachen für Backend-Entwicklung, und genau darin liegt ihr Erfolgsrezept. Der folgende Überblick erklärt, was Go auszeichnet, wo die Sprache heute eingesetzt wird, welche Schwächen sie hat und für welche Teams sie eine gute Wahl ist.

Was Go ist und welches Problem es lösen sollte

Go, oft auch Golang genannt (nach der früheren Website golang.org), entstand ab 2007 bei Google. Die Entwickler Robert Griesemer, Rob Pike und Ken Thompson, einer der Väter von Unix und der Sprache B, wollten eine Sprache für große Serversysteme schaffen, die schnell kompiliert, leicht zu lesen ist und moderne Mehrkernprozessoren gut ausnutzt. Ende 2009 wurde Go als Open Source veröffentlicht, 2012 erschien Version 1.0. Die ausführliche Entstehungsgeschichte erzählt der Beitrag 15 Jahre Go.

Der Hintergrund war ganz praktisch: Bei Google dauerte das Kompilieren großer C++-Projekte teils sehr lange, und der Code war für neue Teammitglieder schwer zu durchschauen. Go sollte die Geschwindigkeit einer kompilierten Sprache mit der Lesbarkeit und dem schnellen Arbeitsfluss einer Skriptsprache verbinden.

Die wichtigsten Eigenschaften lassen sich in wenigen Punkten zusammenfassen:

• Statisch typisiert: Jede Variable hat einen festen Typ, viele Fehler fallen schon beim Kompilieren auf.
• Kompiliert: Der Compiler erzeugt eine einzige ausführbare Datei, die ohne zusätzliche Laufzeitumgebung auskommt.
• Mit Garbage Collection: Die Sprache gibt nicht mehr benötigten Speicher automatisch frei.
• Nebenläufigkeit eingebaut: Mehrere Aufgaben gleichzeitig auszuführen, gehört zum Kern der Sprache.

Einfachheit als Programm

Go hat bewusst wenige Sprachmittel. Es gibt keine Klassen und keine Vererbung, sondern Structs (zusammengesetzte Datentypen) und Interfaces, also Beschreibungen von Methoden, die ein Typ erfüllen muss. Ein Typ erfüllt ein Interface automatisch, sobald er die passenden Methoden hat, ohne dass er das ausdrücklich erklären muss. Statt tiefer Klassenhierarchien setzt Go auf Zusammensetzung aus kleinen Bausteinen.

Diese Kargheit ist Absicht. Angenommen, ein Entwicklungsteam übernimmt einen Dienst, den ein anderes Team vor drei Jahren geschrieben hat. In Go sieht dieser Code mit hoher Wahrscheinlichkeit so aus wie der eigene, weil es für die meisten Aufgaben nur einen üblichen Weg gibt und das Werkzeug gofmt die Formatierung vorgibt. Diskussionen über Klammern und Einrückungen entfallen.

Am deutlichsten zeigt sich die Haltung bei der Fehlerbehandlung. Go kennt keine Exceptions. Fehler sind gewöhnliche Rückgabewerte, die der aufrufende Code prüfen muss:

daten, err := os.ReadFile("konfiguration.json")
if err != nil {
	return fmt.Errorf("konfiguration lesen: %w", err)
}

Das Muster if err != nil taucht in Go-Code ständig auf und ist ein häufiger Kritikpunkt, weil es Code länger macht. Der Vorteil: Jeder mögliche Fehler ist im Code sichtbar, nichts springt unbemerkt durch mehrere Ebenen. Mit %w wird der ursprüngliche Fehler eingebettet, sodass er sich später mit errors.Is oder errors.As auswerten lässt.

Ein kleiner Webdienst mit der Standardbibliothek

Eine Stärke von Go ist die umfangreiche Standardbibliothek. Für einen einfachen Webdienst braucht es kein zusätzliches Framework. Seit Go 1.22 versteht der eingebaute Router auch HTTP-Methoden und Platzhalter in Pfaden:

package main

import (
	"encoding/json"
	"log"
	"net/http"
)

type Auftrag struct {
	ID     string `json:"id"`
	Status string `json:"status"`
}

func main() {
	mux := http.NewServeMux()

	mux.HandleFunc("GET /auftraege/{id}", func(w http.ResponseWriter, r *http.Request) {
		auftrag := Auftrag{ID: r.PathValue("id"), Status: "in Bearbeitung"}
		w.Header().Set("Content-Type", "application/json")
		if err := json.NewEncoder(w).Encode(auftrag); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
	})

	log.Println("Server läuft auf Port 8080")
	log.Fatal(http.ListenAndServe(":8080", mux))
}

Das Programm beantwortet Anfragen wie GET /auftraege/4711 mit einem JSON-Objekt. Groß geschriebene Namen wie Auftrag oder ID sind übrigens außerhalb des Pakets sichtbar, klein geschriebene nicht. Eine eigene Schlüsselwortregel für „public“ und „private“ braucht Go dafür nicht. Wer mehr Komfort möchte, greift zu verbreiteten Bibliotheken wie Chi, Gin oder Echo, nötig sind sie für viele Dienste aber nicht.

Goroutines und Channels: Nebenläufigkeit ohne Kopfzerbrechen

Der wichtigste Grund, warum Go in der Cloud-Infrastruktur so verbreitet ist, heißt Goroutine. Eine Goroutine ist eine Funktion, die nebenläufig zum übrigen Programm läuft. Anders als Threads des Betriebssystems sind Goroutines sehr leichtgewichtig: Sie starten mit wenigen Kilobyte Speicher, und die Go-Laufzeit verteilt sie selbst auf die verfügbaren Prozessorkerne. Ein Server kann so Zehntausende gleichzeitige Verbindungen jeweils in einer eigenen Goroutine bearbeiten.

Für den Austausch zwischen Goroutines gibt es Channels, typisierte Kanäle, über die Werte sicher von einer Goroutine zur anderen wandern. Angenommen, ein Webshop fragt die aktuellen Preise bei mehreren Lieferanten ab. Statt die Anfragen nacheinander zu schicken, startet er sie gleichzeitig und sammelt die Antworten ein:

type angebot struct {
	lieferant string
	preis     float64
	err       error
}

func preiseAbfragen(ctx context.Context, lieferanten []string) []angebot {
	ergebnisse := make(chan angebot, len(lieferanten))

	for _, l := range lieferanten {
		go func() {
			preis, err := preisLaden(ctx, l) // fragt die API des Lieferanten ab
			ergebnisse <- angebot{lieferant: l, preis: preis, err: err}
		}()
	}

	angebote := make([]angebot, 0, len(lieferanten))
	for range lieferanten {
		angebote = append(angebote, <-ergebnisse)
	}
	return angebote
}

Das Schlüsselwort go vor dem Funktionsaufruf startet die Goroutine. Der Parameter ctx vom Typ context.Context trägt Fristen und Abbruchsignale durch das Programm: Läuft die Gesamtzeit ab, können alle laufenden Anfragen gemeinsam abgebrochen werden. Nebenläufigkeit bleibt trotzdem anspruchsvoll. Gleichzeitige Zugriffe auf gemeinsame Daten führen schnell zu schwer auffindbaren Fehlern. Go bringt dafür einen eingebauten Detektor mit, der solche Konflikte beim Testen meldet (go test -race).

Was sich seit 2021 verändert hat

Go entwickelt sich langsam und vorsichtig weiter. Ein Kernversprechen ist die Kompatibilität: Programme, die für Go 1.0 geschrieben wurden, sollen auch mit neuen Versionen weiter kompilieren. Neue Versionen erscheinen zweimal im Jahr, jeweils im Februar und im August.

Die größte Neuerung der letzten Jahre waren Generics mit Go 1.18 im März 2022. Sie erlauben Funktionen und Datentypen, die mit verschiedenen Typen arbeiten, ohne dass der Code für jeden Typ neu geschrieben werden muss:

func Filtern[T any](werte []T, behalten func(T) bool) []T {
	var ergebnis []T
	for _, w := range werte {
		if behalten(w) {
			ergebnis = append(ergebnis, w)
		}
	}
	return ergebnis
}

// Aufruf: offene := Filtern(auftraege, func(a Auftrag) bool { return a.Status == "offen" })

Weitere Änderungen, die im Alltag auffallen:

• Strukturiertes Logging mit dem Paket log/slog (seit Go 1.21) gibt Protokolle als Schlüssel-Wert-Paare oder JSON aus, was die Auswertung in Monitoring-Systemen erleichtert.
• Schleifenvariablen gelten seit Go 1.22 für jeden Durchlauf neu. Eine früher häufige Fehlerquelle bei Goroutines in Schleifen ist damit verschwunden, das Beispiel oben verlässt sich darauf.
• Iteratoren über eigene Funktionen sind seit Go 1.23 mit range möglich.
• Toolchain-Verwaltung: Seit Go 1.21 kann ein Projekt in der Datei go.mod festlegen, welche Go-Version es benötigt, und das Werkzeug lädt sie bei Bedarf selbst.

Im August 2026 erschien Go 1.27. Unterstützt werden jeweils die beiden neuesten Versionen. Ein Update pro Jahr gehört deshalb zur normalen Pflege.

Werkzeuge und Einsatzfelder

Ein Grund für die Beliebtheit ist das mitgelieferte Werkzeugset. Der Befehl go übernimmt Bauen, Testen, Formatieren und die Verwaltung der Abhängigkeiten über Go-Module:

go mod init example.com/preisdienst   # neues Modul anlegen
go run .                              # Programm übersetzen und starten
go test ./...                         # alle Tests ausführen
go vet ./...                          # verdächtige Konstrukte melden
GOOS=linux GOARCH=arm64 go build -o preisdienst .   # für einen Linux-Server mit ARM-Prozessor bauen

Die letzte Zeile zeigt eine Eigenschaft, die im Betrieb viel Arbeit spart: Go übersetzt für andere Betriebssysteme und Prozessoren, ohne zusätzliche Werkzeuge. Das Ergebnis ist eine einzelne Datei, die sich in ein sehr kleines Container-Image packen lässt. Ergänzend gibt es den Sprachserver gopls für Editoren, den Profiler pprof und govulncheck, das die Abhängigkeiten eines Projekts auf bekannte Sicherheitslücken prüft.

Daraus ergeben sich die typischen Einsatzfelder:

• Cloud-Infrastruktur: Docker, Kubernetes, etcd, Terraform, Prometheus und viele weitere Werkzeuge des Cloud-native-Umfelds sind in Go geschrieben.
• Backend-Dienste und APIs: Microservices, Gateways und Dienste, die viele gleichzeitige Anfragen verarbeiten.
• Kommandozeilenwerkzeuge: Etwa die GitHub CLI oder der Static-Site-Generator Hugo, weil sich eine einzelne Datei leicht verteilen lässt.
• Netzwerk- und Datenbanksoftware: Webserver wie Caddy, Proxys wie Traefik oder verteilte Datenbanken wie CockroachDB.

Wo Go an Grenzen stößt

Go ist kein Allzweckwerkzeug. Für Datenanalyse und maschinelles Lernen fehlt das Ökosystem, das Python mit NumPy, pandas und PyTorch bietet. Go wird hier eher für die Dienste rund um ein Modell eingesetzt als für das Training selbst. Für Desktop- und Mobil-Oberflächen gibt es zwar Bibliotheken, aber keine breite Unterstützung.

Wo es auf jede Mikrosekunde ankommt oder kein Garbage Collector laufen darf, etwa bei Treibern, eingebetteten Systemen mit wenig Speicher oder harten Echtzeitanforderungen, sind C, C++ oder Rust die passenderen Sprachen. Rust bietet zudem stärkere Garantien gegen Speicherfehler und Datenkonflikte, verlangt dafür aber deutlich mehr Einarbeitung. Einen Vergleich der drei Sprachen Python, Go und Rust zieht der Beitrag Warum Python, Go und Rust die Softwareentwicklung prägen.

Auch die Einfachheit hat ihren Preis. Manche Entwickler:innen vermissen Sprachmittel wie Aufzählungstypen mit eigener Prüfung durch den Compiler oder eine kürzere Fehlerbehandlung. Die Go-Entwickler wägen solche Wünsche traditionell lange ab, und viele werden bewusst abgelehnt.

Was Go für Ihr Team bedeutet

Die Frage nach der Zukunft von Go lässt sich nüchtern beantworten: Die Sprache ist fest in der Infrastruktur verankert, auf der Cloud-Anwendungen laufen, und sie wird von Google und einer großen Gemeinschaft weiterentwickelt. Ein plötzliches Verschwinden ist unwahrscheinlich. Gleichzeitig wird Go nicht zur Sprache für alles werden, und das ist auch nicht ihr Anspruch.

Für die meisten Teams lohnt sich Go, wenn sie Backend-Dienste, APIs oder interne Werkzeuge bauen, die zuverlässig laufen, wenig Ressourcen brauchen und sich einfach in Container verpacken lassen. Besonders profitieren Organisationen, deren Teams wechseln oder wachsen: Neue Kolleg:innen sind in Go-Code meist schnell produktiv. Wer bereits mit Kubernetes und Containern arbeitet, versteht mit Go-Kenntnissen auch die eigenen Werkzeuge besser.

Weniger sinnvoll ist ein Wechsel, wenn ein Team in Java, C# oder Python bereits produktiv arbeitet und keine konkreten Probleme mit Ressourcenverbrauch, Startzeiten oder Wartbarkeit hat. Unsere Empfehlung: Go zuerst für einen klar abgegrenzten neuen Dienst einsetzen, etwa ein API-Gateway oder einen Hintergrundprozess, und auf dieser Grundlage entscheiden.

Häufige Fragen zu Go

Wie lange dauert es, Go zu lernen?

Wer bereits eine andere Programmiersprache beherrscht, kann die Grundlagen von Go in wenigen Tagen erlernen, denn die Sprachspezifikation ist vergleichsweise kurz. Länger dauert es, idiomatischen Code zu schreiben, also Code, der den Gepflogenheiten der Sprache folgt, und Nebenläufigkeit sicher einzusetzen.

Eignet sich Go für Webanwendungen?

Für das Backend ja, für die Oberfläche im Browser kaum. Typisch ist eine Kombination aus einem Go-Dienst, der eine API bereitstellt, und einem Frontend in einem JavaScript-Framework. Go kann aber auch HTML-Seiten mit dem Paket html/template serverseitig erzeugen.

Ist Go schneller als Java oder Python?

Gegenüber Python ist Go bei rechenintensiven Aufgaben meist deutlich schneller, weil es kompiliert wird. Gegenüber Java ist der Unterschied in der reinen Rechenleistung oft gering. Go punktet dort eher mit kurzen Startzeiten, geringem Speicherbedarf und einfacher Auslieferung als einzelne Datei.

Wer Go im Zusammenhang mit Containern, Kubernetes und Microservices einsetzen möchte, findet auf der Themenseite zu Cloud-native-Entwicklung unsere Angebote für Beratung, Coaching und Seminare.