C1ph4: Die Seite wurde neu angelegt: „{{Infobox Programmiersprache | Name = Go | Logo = Go-Logo 2018-04-26 | Beschreibung = | Paradigma = […“

2018-05-05T09:56:12Z

Die Seite wurde neu angelegt: „{{Infobox Programmiersprache | Name = Go | Logo = 300px|Go-Logo 2018-04-26 | Beschreibung = | Paradigma = […“

Neue Seite

{{Infobox Programmiersprache
| Name = Go
| Logo = [[File:GoLanguage_Logo_2018-04-26_BlackWhite.svg|300px|Go-Logo 2018-04-26]]
| Beschreibung =
| Paradigma = [[Nebenläufigkeit|nebenläufig]], [[Imperative Programmierung|imperativ]], [[Strukturierte Programmierung|strukturiert]], [[Modulare Programmierung|modular]], [[Objektorientierte Programmierung|objektorientiert]]
| Erscheinungsjahr = 2009; erste stabile Version 2012
| Designer =
| Entwickler = [[Robert Griesemer]], [[Rob Pike]], [[Ken Thompson]] u. a.
| AktuelleVersion = 1.10
| AktuelleVersionFreigabeDatum = 16. Februar 2018<ref>[https://golang.org/doc/go1.10''Go 1.10 is released'']</ref>
| AktuelleVorabVersion =
| AktuelleVorabVersionFreigabeDatum =
| Typisierung = [[Starke Typisierung|stark]], [[Statische Typisierung|statisch]]
| Implementierung = Gc, gccgo
| Dialekte =
| Standardisierungen =
| Beeinflusst_von = [[C (Programmiersprache)|C]], [[Newsqueak]], [[Alef (Programmiersprache)|Alef]], [[Limbo (Programmiersprache)|Limbo]], [[Oberon (Programmiersprache)|Oberon]]
| Beeinflusste =
| Betriebssystem = [[Linux]], [[macOS]], [[FreeBSD]], [[Microsoft Windows|Windows]], Experimentell: [[DragonFly BSD]], [[Plan 9 (Betriebssystem)|Plan 9]], [[Solaris (Betriebssystem)|Solaris]]
| Lizenz = [[BSD-Lizenz]]
| Website = [https://golang.org/ golang.org]
}}

'''Go''' ist eine [[Kompilierung|kompilierbare]] [[Programmiersprache]], die [[Nebenläufigkeit]] unterstützt und über eine [[Garbage Collection|automatische Speicherbereinigung]] verfügt. Entwickelt wurde Go von Mitarbeitern des Unternehmens [[Google Inc.]]<ref>[http://www.techcrunch.com/2009/11/10/google-go-language/ Google-go-language]</ref> Die Entwürfe stammen von [[Robert Griesemer]], [[Rob Pike]] und [[Ken Thompson]].

== Überblick ==
Go wurde aus Unzufriedenheit über die bestehenden Sprachen zur Softwareentwicklung wie [[C++]] oder [[Java (Programmiersprache)|Java]] im Kontext heutiger Computersysteme, insbesondere im Hinblick auf [[Skalierbarkeit|skalierbare]] [[Netzwerkdienst]]e, [[Rechnerverbund|Cluster]]- und [[Cloud Computing]], entwickelt.<ref>[https://www.youtube.com/watch?v=FTl0tl9BGdc Why Learn Go?] – Kurzinterview mit Rob Pike (Video, englisch)</ref> Im Vergleich zu C++ hat Go weit weniger Keywords. Eines der Probleme, das Go lösen möchte, ist die Compiler-Ineffizienz in C und C++. Wichtige Ziele bei der Entwicklung waren unter anderem die Unterstützung von Nebenläufigkeit mit nativen Sprachelementen und die Erleichterung der Softwareentwicklung mit großen Entwicklerteams und großen Codebasen.<ref>[http://talks.golang.org/2012/splash.article talks.golang.org]</ref> Go besitzt einen eigenen Garbage Collector, erlaubt die Verwendung von [[Zeiger (Informatik)|Zeigern]], verzichtet jedoch auf Zeigerarithmetik.<ref>[https://golang.org/doc/faq#no_pointer_arithmetic golang.org]</ref> Go ist eine kompilierte Sprache, bei der Wert auf eine hohe Übersetzungsgeschwindigkeit gelegt wurde.

Go orientiert sich syntaktisch an der Programmiersprache [[C (Programmiersprache)|C]] mit einigem Einfluss aus der [[Niklaus Wirth|Wirthschen]] Sprachfamilie ([[Pascal (Programmiersprache)|Pascal]], [[Modula-2|Modula]] und insbesondere [[Oberon (Programmiersprache)|Oberon]]). Die Unterstützung für Nebenläufigkeit wurde nach Vorbild der von [[Tony Hoare]] eingeführten [[Communicating Sequential Processes]] (CSP) gestaltet und steht in Tradition der Programmiersprachen [[Newsqueak]], [[Alef (Programmiersprache)|Alef]] und [[Limbo (Programmiersprache)|Limbo]].<ref>[https://www.youtube.com/watch?v=3DtUzH3zoFo Origins of Go’s Concurrency Model]</ref>

== Merkmale und Sprachmittel ==
Go bietet [[Closure (Funktion)|Closures]] und [[Reflexion (Programmierung)|Reflexion]]<ref>[http://www.golem.de/0911/71113.html Golem.de-Artikel ''Go - schnelle Programmiersprache von Google'']</ref> sowie [[Typsicherheit]] und eine automatische Speicherbereinigung.
[[Objektorientierte Programmierung|Objektorientierung]] unterstützt Go durch [[Schnittstelle (Objektorientierung)|Interfaces]] und [[Mixin]]s. Auf [[Klasse (Objektorientierung)|Klassen]] wird bewusst verzichtet. Außerdem ist es möglich, den Quellcode wie bei [[Java (Programmiersprache)|Java]] durch Pakete zu modularisieren.
Nebenläufigkeit wird durch [[Communicating Sequential Processes]] realisiert, die ''Goroutinen'' genannt werden und über Kanäle ''(Channels)'' miteinander kommunizieren können. [[Generischer Typ|Generische Typen]] gibt es nicht, eine spätere Integration ist aber nicht ausgeschlossen.<ref>[https://golang.org/doc/faq#generics golang.org]</ref>
Unicode wird in Form von [[UTF-8]] unterstützt, sowohl für Strings als auch für Variablenbezeichner im Quelltext (allerdings nur Unicode-Buchstaben und -Ziffern), „Δt = t1 - t2“ ist also möglich.<ref>[https://golang.org/doc/faq#unicode_identifiers golang.org]</ref>

== Syntax ==
Die Syntax von Go orientiert sich im Wesentlichen an der Syntax der Programmiersprache [[C (Programmiersprache)|C]], weicht davon aber an einigen Stellen ab. So kann beispielsweise auf den Abschluss von [[Anweisung (Programmierung)|Anweisungen]] durch ein Semikolon verzichtet werden. Datentypen werden bei [[Deklaration (Programmierung)|Deklarationen]] hinter den Bezeichner geschrieben statt davor, um die Deklaration von Funktionstypen zu vereinfachen.<ref>[http://blog.golang.org/2010/07/gos-declaration-syntax.html blog.golang.org]</ref> Code-Blöcke werden mit geschweiften Klammern abgegrenzt. Neben dem einfachen Gleichheitszeichen als Zuweisungsoperator gibt es zusätzlich den Operator <code>:=</code>, der Deklaration mit [[Typinferenz]] und Zuweisung kombiniert. Die Sprache umfasst mit 25 [[Schlüsselwort (Programmierung)|Schlüsselwörtern]] weniger Schlüsselwörter als [[Varianten der Programmiersprache C|ANSI C]].

Kommentare werden wie in C oder C++ mit Schrägstrichen markiert; <code>/*</code> bis <code>*/</code> bezeichnet einen [[Kommentar (Programmierung)|Kommentarbereich]], der auch mehrere Zeilen beinhalten kann, <code>//</code> leitet einen Kommentarbereich bis zum Ende der Zeile ein.

Jede Quelldatei gehört genau einem Paket an, das am Anfang der Datei mit der <code>package</code>-Anweisung angegeben wird.

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

Jede Variable hat einen definierten Typ.

== Einfache Beispiele ==
<syntaxhighlight lang="go">
package main

import "fmt"

func main() {
fmt.Println("Hallo Welt")
}
</syntaxhighlight>

Der obige Quelltext gibt am Ausgabemedium den String <code>Hallo Welt</code> aus.

Ein weiteres Beispiel berechnet die [[Kreiszahl]] Pi näherungsweise über die [[Leibniz-Reihe]].
Für die Berechnung werden parallele Go-Routinen und ein Kanal verwendet:

<syntaxhighlight lang="go">
package main

import (
"fmt"
"math"
)

func main() {
fmt.Println(calcpi(5000))
}

// calcpi startet n Goroutinen, um eine
// Näherung von Pi zu berechnen.
func calcpi(n int) float64 {
ch := make(chan float64)
for k := 0; k < n; k++ {
// alle n Werte parallel berechnen
go term(ch, float64(k))
}
// das Ergebnis mit Null initialisieren
f := float64(0.0)
for k := 0; k < n; k++ {
// alle n Werte addieren
f += <-ch
}
return f
}

func term(ch chan<- float64, k float64) {
ch <- 4 * math.Pow(-1, k) / (2*k + 1)
}
</syntaxhighlight>

Die einzelnen [[Summand]]en der [[Reihe (Mathematik)|mathematischen Reihe]] werden parallel ausgeführt und schreiben ihre Ergebnisse jeweils in den Kanal <code>ch</code>. Gleichzeitig werden die Werte aus dem Kanal zu einem Gesamtergebnis addiert. Am Ausgabegerät erscheint die Ziffernfolge <code>3.1417926135957934</code>. Die Abweichung zur eigentlichen Kreiszahl ab der vierten Nachkommastelle ist vor allem auf die langsame Konvergenz der [[Leibniz-Reihe]] zurückzuführen.

== Objektorientierung ==
Go unterstützt objektorientierte Programmierung, diese ist jedoch nicht [[Klasse (Objektorientierung)|klassenbasiert]]. Datentypen können in Go [[Methode (Programmierung)|Methoden]] besitzen. [[Polymorphie (Programmierung)|Polymorphie]] wird über ''Interfaces'' ([[Schnittstelle]]n) erreicht, über die Methodenaufrufe zur Laufzeit an die konkrete Implementierung gebunden werden ([[Dynamische Bindung]]). Für einen Datentyp muss nicht explizit deklariert werden, dass er ein bestimmtes Interface erfüllt. Diese Beziehung wird stattdessen implizit beim Kompilieren ermittelt, um lose [[Kopplung (Softwareentwicklung)|Kopplung]] zu erreichen.

Statt [[Vererbung (Programmierung)|Vererbung]] und Typ-Hierarchien kommt in Go Komposition zum Einsatz. Hierfür unterstützt Go eine Form von Mixins, die in Go ''embedding'' („Einbettung“) genannt wird: eine Datenstruktur kann beliebig viele andere Datentypen einbetten, so dass sie deren Methoden und Datenfelder erhält.

Beispiel zu Typen, Interfaces und Mixins:
<syntaxhighlight lang="go">
package main

import "fmt"

// Definieren zweier Typen
type User struct {
Name string
}

type Admin struct {
User // Admin bettet zudem den Typen 'User' ein
Email string
}

// Ein Interface mit der Methode 'Notify()'
type Notifier interface {
Notify()
}

// User und Admin implementieren das Interface 'Notifier'
// Eine vorherige Deklaration zur Implementierung ist nicht notwendig
func (u User) Notify() {
fmt.Printf("User : Sending User Email To %s\n",
u.Name)
}

func (a Admin) Notify() {
fmt.Printf("Admin: Sending Admin Email To %s. His adress is \"%s\".\n",
a.Name, // Verwenden des eingebetteten Feldes 'Name' vom User
a.Email)
}

func main() {
// Einen User und einen Admin erstellen
user := User{
Name: "john smith",
}
admin := Admin{
User: user,
Email: "john@email.com",
}

// Die implementierte Notify-Methode aufrufen
// Mittels dynamischer Bindung wird die Methode am richtigen Typen aufgerufen
user.Notify()
admin.Notify()
}
</syntaxhighlight>

== Nebenläufigkeit ==
Zur Unterstützung der nebenläufigen Programmierung in Go wird das Konzept der Kanäle ''(channels)'' genutzt, das eine relativ stark abstrahierte Möglichkeit der synchronen oder asynchronen Kommunikation zwischen Go-Routinen bietet. Ein Kanal ist dabei ein Speicherbereich, der durch Semaphore abgesichert ist und eine Warteschlange (buffered/asynchronous channel) oder lediglich eine Schnittstelle (unbuffered/synchronous channel) zur Verfügung stellt.<ref>[https://golang.org/doc/effective_go.html#channels golang.org]</ref> Über einen Kanal lassen sich dabei nur Daten eines festen Typs übertragen. Hierbei ist jedoch keinerlei Begrenzung hinsichtlich des Typs gegeben, auch Channels für Channels sind denkbar.<ref>[https://golang.org/doc/effective_go.html#chan_of_chan golang.org]</ref>

Ein Kanal wird durch den Aufruf <code>make(chan typ)</code> (synchron) bzw. <code style="white-space: nowrap">make(chan typ, größe)</code> (asynchron, wenn ''größe'' > 0) erstellt. Anschließend können Go-Routinen in den Channel schreiben, von ihm lesen und ihn schließen.

Bei synchronen Kanälen blockiert ein Lesezugriff, bis eine andere Go-Routine in den Channel schreibt, bzw. der Schreibzugriff, bis eine andere Routine liest.
Bei asynchronen Kanälen tritt ein solches Verhalten nur auf, wenn der zu lesende Channel leer bzw. der zu schreibende Channel voll ist.
Es gibt in Go keine Beschränkung hinsichtlich der Anzahl an Go-Routinen, die einen Channel lesen und schreiben.
Trotz der ausgefeilten Synchronisationsmechanismen kann bei der Benutzung von Channels ein Deadlock auftreten, welcher die Go-Laufzeitumgebung veranlasst, das Programm zu beenden.
Eine Go-Routine kann über das <code>select</code> Konstrukt auf mehreren Channels gleichzeitig lauschen, bzw. versuchen, in mehrere Channels zu schreiben, wobei dasjenige <code>case</code>-Statement ausgeführt wird, welches zuerst nicht mehr blockiert.

Daten werden mit <code>kanal <- Wert</code> in einen Kanal geschrieben und mit <code style="white-space: nowrap">variable = <-kanal</code> gelesen, wobei beim Lesen die Variablenzuweisung wegfallen kann. Das Lauschen auf einem Channel kann auch mit dem <code>for</code>-Konstrukt automatisiert werden, wobei die Schleife verlassen wird, sobald der Channel geschlossen wird.

Beispiel:
<syntaxhighlight lang="go">
package main

import "fmt"

func zehnMal(kanal chan string) {
// Argument empfangen
sag := <-kanal

// Zehnmal zurückschreiben
for i := 0; i < 10; i++ {
kanal <- sag
}

// Kanal schließen
close(kanal)
}

func main() {
// synchronen Kanal öffnen
kanal := make(chan string) // oder make(chan string, 0)

// Starten der parallelen Go-Routine „zehnMal()“
go zehnMal(kanal)

// Senden eines Strings
kanal <- "Hallo"

// Empfangen der Strings, bis der Channel geschlossen wird
for s := range kanal {
fmt.Println(s)
}

fmt.Println("Fertig!")
}
</syntaxhighlight>

Im Beispiel ruft <code>main()</code> die Go-Routine <code>zehnMal()</code> auf, die einen empfangenen String zehnmal über den gleichen Kanal zurückgibt und ihn danach schließt. Durch den synchronen Kanal warten die beiden Go-Routinen aufeinander, sodass <code>main()</code> erst in die <code>for</code>-Schleife eintritt, wenn <code>zehnMal()</code> den String empfangen hat. Wäre der Kanal nicht synchron, könnte ein Deadlock auftreten, wenn main() die geschriebene Variable sofort wieder liest (und aus dem Puffer entfernt) und <code>zehnMal()</code> vergeblich auf sein Argument wartet. Wichtig ist auch, dass <code>zehnMal()</code> nach dem Schreiben der Strings den Kanal schließt, da <code>main()</code> sonst die Schleife nicht verlassen kann.

== Implementierungen ==
Es gibt mindestens zwei [[Compiler]] für Go, die auf [[Linux]], [[macOS]], [[Microsoft Windows|Windows]] und [[FreeBSD]] betrieben werden können und die Go 1 Spezifikation vollständig implementieren:
; Gc
: ist der offizielle Go-Compiler und wurde initial von Ken Thompson in C geschrieben, basierte auf der [[Plan 9 (Betriebssystem)|Plan 9]] [[Toolchain]] und nutzte [[Yacc]]/[[GNU Bison|Bison]] zum [[Parser|Parsen]]. Mit Version 1.5 wurde dieser Compiler von C nach Go übersetzt und ist damit ''self-hosting''. Ursprünglich bestand der Compiler aus mehreren ausführbaren Kommandos, die unterschiedliche Namen je nach Ziel-Architektur hatten: 8g für [[x86]], 6g für [[AMD64|x86_64]], 5g für [[ARM-Architektur|ARM]]. Mit Version 1.5 wurden diese zu einem einzelnen ausführbaren Kommando zusammengefasst (''go tool compile''), und die Ziel-Architektur kann über die Umgebungsvariable ''GOARCH'' gewählt werden.
; Gccgo
: von Ian Taylor ist ein Go-[[Front-End und Back-End|Frontend]] für die [[GNU Compiler Collection]] (GCC). Das in [[C++]] geschriebene Frontend nutzt zum Parsen einen [[Rekursiver Abstieg|rekursiven Abstieg]]. Die folgenden Backend-Schritte sind die der Standard-GCC-Verarbeitung<ref>[https://golang.org/doc/faq#Implementation golang.org/doc/faq#Implementation]</ref>. Durch dieses Vorgehen wird zwar die [[Kompilierzeit]] im Vergleich zum Gc-Compiler erhöht, jedoch ist der produzierte Code effizienter. Die GNU Compiler Collection (GCC) unterstützt Go 1 mit Version 4.7.1 vollständig,<ref>[http://gcc.gnu.org/gcc-4.7/changes.html GCC 4.7 Release Series Changes, New Features, and Fixes]</ref> der [[GNU Debugger]] (gdb) unterstützt Go ab Version 7.5.<ref>[http://sourceware.org/ml/gdb-announce/2012/msg00004.html GDB 7.5 Release Notes]</ref>

Beide Compiler implementieren eine parallele [[Automatische Speicherbereinigung#Mark-and-Sweep-Algorithmus|Mark-and-Sweep-Speicherbereinigung]].

Der offizielle Compiler wird von dem [[Kommandozeile]]n-Werkzeug ''go'' begleitet, das als Fassade für verschiedene Werkzeuge dient, wie z. B. dem Installieren von Paketen aus Quelltext-[[Repository|Repositories]] im Internet wie etwa [[GitHub]] oder [[Google Code]] ''(go get)'', dem automatischen Formatieren von Quelltext ''(go fmt)'', dem Ausführen von [[Modultest|Tests]] ''(go test)'', dem Erzeugen von Dokumentation aus Quelltext-Kommentaren ''(go doc)'' oder dem Kompilieren des Projektes ''(go build)'', so dass keinerlei [[Make]]files nötig sind, wenn eine empfohlene Verzeichnisstruktur eingehalten wird.

== Geschichte ==
Die Entwurfsphase begann am 21. September 2007, anfangs als 20-Prozent-Projekt auf Initiative von Robert Griesemer, Rob Pike und Ken Thompson. Bald darauf stießen weitere Entwickler dazu, und Go wurde zum Vollzeit-Projekt.<ref>[https://golang.org/doc/faq Informationen zur Geschichte in offizieller FAQ]</ref> Am 30. Oktober 2009 wurde Go von Rob Pike in einem Google TechTalk präsentiert und die Veröffentlichung als [[freie Software]] angekündigt, die dann wie angekündigt am 10. November erfolgte.<ref>[http://google-opensource.blogspot.de/2009/11/hey-ho-lets-go.html ursprüngliche Nachricht über die Veröffentlichung im Google Open Source Blog]</ref><ref>[https://www.heise.de/ix/meldung/Go-Googles-Programmiersprache-fuer-Abenteuerlustige-855912.html iX-Artikel vom 11. November 2009]</ref> Seitdem sind zahlreiche Beiträge von Entwicklern aus der Go-Community außerhalb Googles hinzugekommen. Am 28. März 2012 wurde Version 1 freigegeben.<ref>[http://blog.golang.org/2012/03/go-version-1-is-released.html Freigabe der Version 1 im ''Go Programming Language Blog'']</ref> Seitdem gelten Sprachspezifikation und Standardbibliothek als stabil und sollen innerhalb der 1.x-Serie auf Quelltext-Ebene abwärtskompatibel bleiben.<ref>[https://golang.org/doc/go1compat.html golang.org]</ref> Am 14. Mai 2013 wurde Go 1.1 freigegeben, das vor allem [[Rechenleistung|Performance]]-Verbesserungen an der Implementierung enthält.<ref>[http://blog.golang.org/2013/05/go-11-is-released.html blog.golang.org]</ref> Jeweils sechs Monate später erschienen die Versionen Go 1.2 bis Go 1.10.

Vom 24. bis zum 26. April 2014 fand die erste Konferenz zu Go, die GopherCon,<ref>[http://gophercon.com/ GopherCon]</ref> in [[Denver]] statt, welche seitdem jährlich stattfindet.

== Maskottchen ==
[[File:The Go Gopher.jpg|thumb|Das Gopher-Maskottchen von Go|300x300px]]
Das Go-Maskottchen ist eine [[Taschenratte]] (englisch ''Gopher''). Es wurde von Renée French entworfen, die auch Glenda, das [[Plan 9 (Betriebssystem)|Plan-9]]-Häschen entworfen hat. Das Logo und das Maskottchen stehen unter der [[Creative Commons]] Attribution 3.0 Lizenz.

== Literatur ==
* {{Literatur
|Autor=Alan A. A. Donovan, Brian W. Kernighan
|Titel=The Go Programming Language
|Verlag=Pearson Education
|Jahr=2015
|ISBN=978-0-13-419044-0}}
* {{Literatur
|Autor=Frank Müller
|Titel=Systemprogrammierung in Google Go: Grundlagen, Skalierbarkeit, Performanz, Sicherheit
|Verlag=dpunkt.verlag
|Ort=Heidelberg
|Jahr=2011
|ISBN=978-3-89864-712-0}}
* {{Literatur
|Autor=Rainer Feike
|Titel=Programmierung in Google Go: Neuigkeiten von Google in der Systemprogrammierung
|Verlag=Addison-Wesley
|Ort=München/Boston
|Jahr=2010
|ISBN=978-3-8273-3009-3}}
* {{Literatur
|Autor=Caleb Doxsey
|Titel=[http://www.golang-book.com/ An Introduction to Programming in Go]
|Jahr=2012
|ISBN=978-1-4783-5582-3}}

== Weblinks ==
* [https://golang.org/ Offizielle Website] (englisch)
** [https://golang.org/ref/spec Spezifikation] (englisch)
** [https://tour.golang.org/ Eine interaktive Einführungs-Tour] (englisch)
* Übersetzungen (deutsch)
** [http://go-tour-de1.appspot.com/ Eine Tour durch Go]
** [http://www.bitloeffel.de/DOC/golang/go_spec_de.html Sprachbeschreibung usw.]
* [https://talks.golang.org/2012/splash.article Go at Google: Language Design in the Service of Software Engineering] – Artikel von Rob Pike über das Sprachdesign (englisch)
* [https://www.youtube.com/watch?v=rKnDgT73v8s Vortrag von Rob Pike] vom 30. Oktober 2009 ([http://talks.golang.org/2009/go_talk-20091030.pdf Präsentationsfolien] (PDF; 242 kB))
* [http://go-lang.cat-v.org/ Go Language Resources] (englisch)
* [http://www.admin-magazin.de/Das-Heft/2012/04/Programmieren-mit-Go Programmieren mit Go] (ADMIN-Magazin)
* [http://helmbold.de/artikel/pro-contra-go Pro und contra Go] (deutsch)
* [https://gobyexample.com/ Go by example] (englisch)

== Einzelnachweise ==
<references />

{{Navigationsleiste Google-Produkte}}
{{Normdaten|TYP=s|GND=7725033-3}}

[[Kategorie:Programmiersprache]]
[[Kategorie:Google]]
[[Kategorie:Freies Programmierwerkzeug]]

Go (Programmiersprache) - Versionsgeschichte

C1ph4: Die Seite wurde neu angelegt: „{{Infobox Programmiersprache | Name = Go | Logo = Go-Logo 2018-04-26 | Beschreibung = | Paradigma = […“