Go (Programmiersprache)

Go
Basisdaten
Paradigmen:	nebenläufig, imperativ, strukturiert, modular
Erscheinungsjahr:	2009
Entwickler:	Robert Griesemer, Rob Pike, Ken Thompson
wichtige Implementierungen:	Gc, gccgo
Einflüsse:	C, Limbo, Modula-2
Betriebssystem:	Linux, Mac OS X
Lizenz:	BSD-Lizenz
golang.org

Go ist eine kompilierbare, nebenläufige Programmiersprache mit (je nach Implementierung) automatischer Speicherbereinigung.

Sie wurde von Mitarbeitern des Unternehmens Google Inc.^[1] entwickelt, die Entwürfe stammen von Robert Griesemer, Rob Pike und Ken Thompson.

Hintergründe, Entwicklungsziele

Go ist vor allem anderen als Sprache zur Systemprogrammierung gedacht. Ebenso wie die Programmiersprachen C und C++ bietet Go die Möglichkeit, Hardware-nahe Software zu programmieren. Es wird jedoch versucht, auf fehleranfällige Sprachfeatures zu verzichten und diese durch modernere Konzepte zu ersetzen. Dazu gehört der Verzicht auf Vererbung und das Weglassen von Exceptions zur Fehlerbehandlung.^[2] Weiterhin soll dem zunehmenden verteilten Rechnen auf Mehrkernprozessoren oder Rechnerverbünden Rechnung getragen werden.

Merkmale, Sprachmittel

Go bietet Closures und Reflexion^[3] sowie Typsicherheit und eine Garbage Collection. Objektorientierung unterstützt Go durch Interfaces und Mixins. Auf Vererbung von Klassen wird bewusst verzichtet. Außerdem ist es möglich den Quellcode wie bei Java durch 'Pakete' zu modularisieren. Nebenläufigkeit wird durch Communicating Sequential Processes realisiert. Generics werden zur Zeit noch nicht unterstützt, wobei fraglich ist, ob diese zukünftig unterstützt werden.^[4] Im Gegensatz zu vielen anderen Programmiersprachen wird Unicode explizit unterstützt, sowohl für Strings als auch für Variablenbezeichner im Quelltext (hier allerdings derzeit "nur" Unicode-Buchstaben und -Ziffern), „Δt = t1 - t2“ ist also möglich.^[5]

Syntax

Die Syntax von Go orientiert sich mit Ausnahme der Datentypdeklarationen an der Programmiersprache C. Code-Blöcke werden mit geschweiften Klammern abgegrenzt.

Kommentare werden wie in C oder C++ mit Schrägstrichen markiert; „/*“ bis „*/“ bezeichnet einen Kommentarbereich, der auch mehrere Zeilen beinhalten kann, „//“ leitet einen Kommentarbereich bis zum Ende der Zeile ein.

Jede Quelldatei gehört genau einem Paket an, das am Anfang der Datei mit der „package“-Anweisung angegeben wird.

Das Schlüsselwort für Funktionen lautet „func“, die Funktion „main“ in dem „main“-Paket ist der Startpunkt des Go-Programms.

Jede Variable hat einen definierten Typ.

Einfaches Beispiel mit Textausgabe

package main
 
import "fmt"
 
func main(){
  fmt.Printf("Hello, World\n")
}

Ein weiteres Beispiel approximiert die Kreiszahl Pi über eine Monte-Carlo-Simulation. Für die Berechnung werden Goroutinen und Channel verwendet:

import (
        "fmt"
        "math"
)
 
func main() {
        fmt.Println(pi(5000))
}
 
// pi launches n goroutines to compute an
// approximation of pi.
func pi(n int) float64 {
        ch := make(chan float64)
        for k := 0; k <= n; k++ {
                go term(ch, float64(k))
        }
        f := float64(0.0)
        for k := 0; k <= n; k++ {
                f += <-ch
        }
        return f
}
 
func term(ch chan float64, k float64) {
        ch <- 4 * math.Pow(-1, k) / (2*k + 1)
}

Implementierung

Es gibt derzeit zwei Compiler für Go, die auf Linux und Mac OS X lauffähig sind:

6g

(je nach Architektur: 8g = x86, 6g = x86_64, 5g = ARM^[6]; zusammen mit seinen Zusatzwerkzeugen als Gc bezeichnet) ist von Ken Thompson in C geschrieben und nutzt Yacc/Bison zum Parsen.

Gccgo

von Ian Taylor ist ein Go-Frontend zum C-Compiler der GCC. Es hat eine C++-Eingabe mit einem rekursiven Abstieg in Verbindung mit einer Standard-GCC-Ausgabe^[7] und benötigt ein Vielfaches an Kompilierzeit verglichen zu 6g, produziert aber effizienteren Code.

Gccgo hat noch keine automatische Speicherbereinigung, 6g implementiert eine einfache Mark-and-Sweep-Speicherbereinigung; beide sollen Speicherbereinigung nach Vorbild von IBMs Recycler-Algorithmus^[8] durch eine gemeinsame Laufzeitbibliothek erhalten, von der erwähnte verzögerungsfreie Betrieb und nur minimaler zusätzlicher Rechenaufwand erwartet wird. Ein besonderer Debugger sei in der Entwicklung, bei der Nutzung von Gccgo kann GNU Debugger (gdb) genutzt werden, der Go als C-Code behandelt und daher keine Kenntnisse über die Laufzeitbibliotheken hat. Unterstützung für Go in der GNU Compiler Collection (GCC) wurde mit Version 4.6 als optional eingeführt.^[9][10]

Als zusätzliche Werkzeuge kommt Go u.a. mit

Godoc,

einem Software-Dokumentationswerkzeug, das (analog zu Javadoc) automatisch Dokumentationen zu einem Quelltext erzeugen kann

Gofmt,

einem Programm zur automatischen Formatierung des Quelltextes.

Goinstall,

einem Programm zur Installation externer Pakete von GitHub, Google Code und anderer Hosting-Plattformen (ähnlich zu RubyGems).

Geschichte

Go orientiert sich an den Programmiersprachen C (Syntax) und Pascal (bzw. dessen Nachfolgern Modula-2 und Oberon). Die Unterstützung für Nebenläufigkeit wurde nach Vorbild der von Tony Hoare eingeführten Communicating Sequential Processes (CSP) gestaltet (ähnlich Occam oder Limbo). Die Entwurfsphase begann am 21. September 2007.^[11] Am 30. Oktober 2009 wurde Go von Rob Pike in einem Google TechTalk präsentiert und die Veröffentlichung als freie Software angekündigt, welche dann wie angekündigt am 10. November vollzogen wurde.^[12]

Literatur

• Frank Müller: Systemprogrammierung in Google Go: Grundlagen, Skalierbarkeit, Performanz, Sicherheit. 2011. dpunkt.verlag. ISBN: 978-3-89864-712-0
• Rainer Feike, Steffen Blass: Programmierung in Google Go: Neuigkeiten von Google in der Systemprogrammierung. 2010. Addison-Wesley. ISBN: 978-3-8273-3009-3

Weblinks

• Offizielle Website (englisch)
  • Spezifikation (englisch)
  • Anleitung (englisch)
• Anleitung (deutsch)
• Vortrag von Rob Pike vom 30. Oktober 2009 (Präsentationsfolien in PDF, 242 KB)
• Go Language Resources (englisch)

Quellen

• iX-Artikel vom 11. November 2009

1. ↑ Google-go-language
2. ↑ http://golang.org/doc/go_faq.html
3. ↑ Golem.de-Artikel Go - schnelle Programmiersprache von Google
4. ↑ http://golang.org/doc/go_faq.html
5. ↑ http://golang.org/doc/go_faq.html#unicode_identifiers
6. ↑ Walter, Jörg: "Weniger ist mehr", erschienen in: c't 18/2011, S. 182ff
7. ↑ golang.org/doc/go_faq.html#Implementation
8. ↑ www.research.ibm.com/people/d/dfb/papers.html
9. ↑ Meldung auf heise online: Viele Neuerungen bei GCC 4.6
10. ↑ GCC 4.6 Release Series Changes, New Features, and Fixes
11. ↑ Informationen zur Geschichte in offizieller FAQ
12. ↑ ursprüngliche Nachricht über die Veröffentlichung im Google Open Source Blog