Was ist Go?

Kurz gesagt: Was ist Go?

Die offizielle Sprach-Spezifikation beschreibt Go selbst so:

Go is a general-purpose language designed with systems programming in mind. It is strongly typed and garbage-collected and has explicit support for concurrent programming.

Das umfasst die fünf Kern-Eigenschaften:

• Allzwecksprache — Backend-APIs, CLIs, Tools, Container-Runtimes, Build-Systeme. Auch für Embedded und WebAssembly geeignet.
• Statisch und stark typisiert — Typen werden zur Compile-Zeit geprüft, implizite Konvertierungen gibt es kaum.
• Kompiliert — Quellcode wird direkt zu Maschinencode übersetzt; ein einzelnes Binary läuft ohne externe Runtime.
• Garbage-collected — kein manuelles malloc/free; ein konkurrierender Collector mit Sub-Millisekunden-Pausen.
• Nebenläufigkeit als Sprachfeature — Goroutines und Channels sind keine Library, sondern in die Sprache eingebaut.

Ein minimales Go-Programm sieht so aus:

package main

import "fmt"

func main() {
    fmt.Println("Hallo, Welt!")
}

Hallo, Welt!

Drei Dinge fallen sofort auf: jede Datei beginnt mit package, der Eintrittspunkt ist func main(), und Imports stehen explizit am Dateianfang. Mehr Zeremonie als in Python, weniger als in Java.

Geschichte und Hintergrund

Go wurde Ende 2007 bei Google als Reaktion auf den Frust mit C++ in großen Server-Codebases gestartet. Drei Personen bilden den Ursprung:

• Robert Griesemer — vorher V8 JavaScript-Engine und HotSpot.
• Rob Pike — Mit-Erfinder von Plan 9, UTF-8 und vieles aus den Bell Labs.
• Ken Thompson — Mit-Erfinder von Unix, der B-Programmiersprache und UTF-8 (mit Pike).

Veröffentlicht wurde Go als Open-Source-Projekt im November 2009. Version 1.0 erschien im März 2012 mit dem Versprechen, dass Go-1-Code für die gesamte 1.x-Linie weiterhin kompiliert. Dieses Compatibility Promise hält bis heute.

Wichtige Meilensteine:

• Go 1.5 (2015) — Compiler in Go selbst geschrieben (Self-Hosting); konkurrierender Garbage Collector.
• Go 1.11 (2018) — Module (go.mod) als neuer Dependency-Mechanismus, parallel zum alten GOPATH.
• Go 1.16 (2021) — Module sind Default; embed-Paket; Filesystem-Interfaces (io/fs).
• Go 1.18 (2022) — Generics mit Type Parameters und Constraints.
• Go 1.21 (2023) — Pakete slices, maps, cmp als idiomatische Helfer; integriertes log/slog.
• Go 1.22 (2024) — Loop-Variablen pro Iteration neu (behebt klassische Closure-Falle); Range-over-Integer.
• Go 1.23+ (seit 2024) — Range-over-Func als Iterator-Mechanismus; weitere Stdlib-Konsolidierung.

Heute wird Go von einem Team bei Google koordiniert (Tech-Lead: Russ Cox), die Entwicklung läuft offen über die go.dev-Infrastruktur und Vorschläge im Go Proposal Process.

Die Go-Philosophie

Go ist eine opinionated Sprache. Sie hat klare Vorlieben darüber, wie Code aussehen soll, und setzt das mit Sprachdesign und Toolchain durch.

• Einfachheit vor Ausdruckskraft. Wenige Konzepte, dafür konsequent. Keine Klassen, keine Vererbung, keine Operator-Overloads, keine Macros, keine Annotations. Die ganze Sprach-Spec passt in ein gut lesbares Dokument.
• Lesbarkeit vor Abstraktion. Code wird viel öfter gelesen als geschrieben. Go bevorzugt explizite Wiederholung über versteckte Abstraktion. Klare Function-Signaturen, sichtbare Fehlerbehandlung, keine Magic.
• Kompilation in Sekunden, nicht Minuten. Eine ganze Codebase mit hunderttausend Zeilen kompiliert oft schneller als ein einzelnes C++-Modul. Schnelle Builds verändern, wie man arbeitet.
• Eine Art, etwas zu tun. gofmt formatiert Code für dich — keine Diskussion über Tabs vs. Spaces. go vet warnt vor üblichen Bugs. Der Linter staticcheck ist Quasi-Standard.
• Erfolgreich pragmatisch. Errors sind Werte, keine Exceptions. Generics kamen erst nach 12 Jahren — und dann minimal. Concurrency über Channels, nicht über async/await.

Errors als Werte ist ein gutes Beispiel. Statt try/catch gibt jede fehleranfällige Funktion explizit zwei Werte zurück:

data, err := os.ReadFile("config.json")
if err != nil {
    return fmt.Errorf("config laden: %w", err)
}
// ... mit data weiterarbeiten

Manche finden das ermüdend repetitiv. Andere lieben es, weil jeder mögliche Fehlerpfad sichtbar im Code steht.

Die Toolchain

Mit Go installierst du nicht nur einen Compiler, sondern ein integriertes Werkzeug-Set. Alle Sub-Befehle starten mit go:

• go run main.go — kompilieren und sofort ausführen, ohne Zwischen-Binary.
• go build — Binary für die aktuelle Plattform erzeugen. GOOS=linux GOARCH=amd64 go build für Cross-Compilation — ohne Container.
• go test — Tests aus *_test.go-Dateien laufen lassen. Test-Framework gehört zur Stdlib.
• go fmt / gofmt — Code-Formatierung. Wird typischerweise vor jedem Commit ausgeführt.
• go vet — statische Analyse für übliche Bugs (Format-String-Probleme, Mutex-Misuse, unreachable code).
• go mod tidy — Dependency-Datei go.mod aufräumen (unbenutzte Imports raus, fehlende rein).
• go doc — Doku eines Pakets oder einer Funktion direkt im Terminal.

Externe Tools komplettieren das Bild: gopls als Language Server für Editoren, golangci-lint als Multi-Linter, pprof für Profiling, delve für Debugging.

Cross-Compilation in einem Befehl, statisch gelinkte Binaries ohne externe Abhängigkeiten — das hat Go zur Sprache der Wahl für CLI-Tools und Container-Workloads gemacht.

Was die Sprache mitbringt

Die Sprach-Features im Überblick:

• Statische Typen mit Type Inference (x := 42 statt var x int = 42).
• Strukturen statt Klassen. Methoden hängen an Typen, nicht an Klassen-Definitionen. Vererbung gibt es nicht — Komposition über Embedding.
• Interfaces sind implizit. Ein Typ implementiert ein Interface allein dadurch, dass er die passenden Methoden hat — keine implements-Deklaration.
• Goroutines. Eine Goroutine ist ein leichtgewichtiger Thread, gestartet mit go funcName(). Tausende sind kein Problem, der Scheduler verteilt sie auf OS-Threads.
• Channels. Typisierte Pipes für Kommunikation zwischen Goroutines. Das idiomatische Concurrency-Modell: „Don't communicate by sharing memory; share memory by communicating."
• Generics seit Go 1.18 — Type Parameters mit Constraints für wirklich generische Container und Algorithmen. Bewusst zurückhaltend gehalten.
• Errors als Werte, nicht Exceptions. Plus panic/recover für unrecoverable Situationen.
• Garbage Collection mit Sub-Millisekunden-Pausen, optimiert auf Latenz statt Throughput.

Und vor allem: eine außergewöhnlich umfangreiche Standardbibliothek. HTTP-Server (net/http), JSON (encoding/json), Templating (text/template, html/template), Crypto (crypto/*), Datum/Zeit (time), Filesystem (io/fs, os), Reguläre Ausdrücke, Compress, Image-Verarbeitung — alles dabei, ohne Dependency-Management auch nur anzufassen.

Wie sieht Go-Code aus?

Ein etwas ausführlicheres Beispiel zeigt mehr Sprachelemente auf einmal:

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
)

type Server struct {
    startedAt time.Time
}

func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
    uptime := time.Since(s.startedAt).Round(time.Second)
    fmt.Fprintf(w, "ok — uptime: %s\n", uptime)
}

func main() {
    srv := &Server{startedAt: time.Now()}

    http.HandleFunc("/health", srv.handleHealth)

    log.Println("listening on :8080")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        log.Fatal(err)
    }
}

Was hier passiert:

• type Server struct { ... } — ein einfacher Wert-Typ mit einem Feld.
• func (s *Server) handleHealth(...) — eine Methode mit Pointer-Receiver auf *Server.
• srv := &Server{...} — Instanziierung mit Composite-Literal und Adress-Operator.
• http.HandleFunc("/health", srv.handleHealth) — Methode wird als gewöhnliche Funktion übergeben (First-Class).
• if err := ...; err != nil — if mit Initialisierungs-Anweisung; klassisches Go-Idiom.

Das ist ein vollwertiger HTTP-Server mit Health-Check in 25 Zeilen. Ohne Framework, ohne externe Dependencies — nur Stdlib.

Stärken

• Konsistenz. gofmt formatiert alles gleich, der gleiche Stil überall — quer durch Open-Source und Firmen-Codebases.
• Schnelle Builds. Sekunden statt Minuten. Verändert das ganze Entwickel-Tempo.
• Eine einzige statische Binary. Deployment-Story ist trivial: Datei kopieren, ausführen.
• Solide Concurrency. Goroutines + Channels sind so direkt, dass nebenläufiger Code lesbar bleibt.
• Stabilität. Das Compatibility Promise — Go-1-Code, der heute läuft, läuft auch in fünf Jahren.
• Stdlib. Du brauchst für die meisten Server-Workloads keine zusätzlichen Frameworks.
• Cross-Compilation out-of-the-box. Auf macOS für Linux/ARM bauen, in einem Befehl.

Grenzen

• Verbose Error-Handling. if err != nil { return ... } taucht häufig auf. Manche stört das, manche schätzen es.
• Keine Sum Types / Tagged Unions. Generics helfen bei manchen Patterns; echte algebraische Datentypen fehlen.
• Generics sind bewusst minimal. Keine Higher-Kinded Types, keine Methoden auf Type-Parametern.
• GUI- und Frontend-Entwicklung. Nicht das Zielgebiet von Go. Backend, CLI und Systeme sind die natürlichen Domänen.
• Reflection ist begrenzt. Was in Java/C# über Annotations/Attributes geht, läuft in Go über Code-Generierung (go generate).
• Kompakte Sprache, große Standardbibliothek. Wer aus dem Java-Umfeld kommt, sucht oft Frameworks, die es in Go bewusst nicht gibt.

Weiterführende Ressourcen

Externe Quellen

• Go – Offizielle Sprach-Spezifikation
• Go – Documentation Hub
• Effective Go – Idiomatic-Go-Leitfaden
• The Go Programming Language Blog
• Go 1 and the Future of Go Programs (Compatibility Promise)
• A Tour of Go – interaktiver Einstieg
• Go Wiki: Why Go?

Verwandte Artikel

• Setup und Installation
• Erstes Programm
• Projektstruktur und go.mod
• Pakete und Imports
• Naming Conventions