Eine (nicht ganz objektive) Einführung in Go

7 languages in 7 months, 2019-09-18

Sebastian Sprenger

Software Engineer

@sebsprenger

Arbeitet bei Breuninger an breuninger.com

Clean Code und Architektur

Generalist mit Sprach- kenntnissen in C/C++, Java, JavaScript, Python und Go

SEBASTIAN SPRENGER

Meine Ziele

● Überblick wieso Go ist wie es ist● Vorstellung von ausgewählten Sprachfeatures● Concurrency demonstrieren

Euch Bock machen auf Go

Ich könnte ewig reden, aber versuche mich auf diese Ziele zu fokussieren.

● Code Beispiele● Vorstellung des Ökosystems● Weiterführende Informationen

Euch enablen Go auszuprobieren

Today’s (glorious) blather.

Sprachen 01

go’s opinions

Code

Ökosystem

Zusammenfassung

Ausblick

02

03

04

05

06

SPRACHEN

JavaScriptC/C++Java

{Sprachen

JavaScriptC/C++

Java

Compiled? Interpreted? Bytecode?Rigid types? Dynamic types?Object/field/method Visibility?Malloc/free? Garbage Collection?Pointers? References?(Checked) Exceptions? Return Codes?Concurrency? Functions?

~ Pretty much everyone

Brauchen wir wirklich noch eine Sprache?

TIOBE Index

● Populäre Sprachen sind recht alt

Historie

1975 1980 1985 1990 1995 2000 2005 2010 2015

1972 C1985 C++

1986 Erlang

1990 Python

1995 Java1995 JavaScript1995 Ruby1995 PHP

2003 Groovy

2004 Scala

2009 Go

2010 Rust

2011 Elixir2011 Kotlin

2014 Swift2000 C#

Wunschliste bei Google

● Einfach zu programmieren wie eine interpretierte, dynamische Sprache

● Effizient und sicher wie eine statisch typisierte und kompilierte Sprache

● Modern, mit Support für Netzwerke und Multi Core Computing

● Schnell: Es soll höchstens wenige Sekunden dauern, um ein großes Executable auf einem einzelnen Computer zu bauen

{Warum noch eine Sprache?

Eine neue Sprache

● Ein ausdrucksstarkes, aber leichtgewichtiges Typsystem

● Concurrency● Garbage Collection● etc

go’s opinionsEine Sprache mit Attitüde

go’s opinions

HotSpotChrome V8

Robert Griesemer Rob Pike Ken ThompsonUNIX, Plan 9

UTF-8UNIX

sh, ed, B, C

go’s opinions

● Einstimmiger Konsens○ Ein Feature findet seinen Weg nur dann in die Sprache,

wenn alle drei denken, dass es eine gute Idee ist○ Go ist nicht “feature bloated”

● Go möchte eine Sprache für die reale Welt sein● Andere Sprachen konvergieren, Go nicht

○ Java kann Functions○ JavaScript hat Klassen

go’s opinions

● Leichtgewichtige Syntax, starkes Typsystem● Garbage collected● Kompiliert so schnell wie bytecode● Cross-kompiliert in self-contained executable● Return Codes statt Exceptions● Funktionen sind First Class Citizens● Communicating Sequential Processes● Schnell

~ Einer meiner Kollegen

Ich habe gehört, dass man in Go nicht so viel können muss...

{go’s opinions

Simplicity

Jedes Sprachfeature soll einfach zu begreifen sein.

go’s opinions

● Da “fehlt” etwas○ Keinen ternären Auswahloperator○ Keine Vererbung○ Keine Generics

● Tendenz zur Zuverlässigkeit○ G’scheite Pointer○ Garbage Collection○ Concurrency Paradigmen○ Return Codes

{go’s opinions

Orthogonality

Features sollen vorhersehbar und konsistent funktionieren.

Orthogonality am Beispiel Maps & Slices

https://play.golang.org/p/GtFlZvfCLvE

m := make(map[string]int)

m["k1"] = 2m["k2"] = 3m["k3"] = 5

mapValue := m["k1"]fmt.Printf("Value is %d\n", mapValue)

for k, v := range m { fmt.Printf("key=%s, value=%d\n", k, v)}

fmt.Printf("Length of map: %d\n", len(m))

s := make([]int, 3)

s[0] = 7s[1] = 11s[2] = 13

sliceValue := s[1]fmt.Printf("Value is %d\n", sliceValue)

for i, v := range s { fmt.Printf("index=%d, value=%d\n", i, v)}

fmt.Printf("Length of slice: %d\n", len(s))

go’s opinions

● Großartig für System Programmierung○ Server (Netzwerk, Multi Core, etc)○ CLI (self contained)

● Suboptimal für Embedded und Desktop UIs○ Runtime (Größe und Garbage Collection)○ Kein natives UI Konzept

go’s opinions

● Moderne Standard Library○ Network, Crypto, Templating, Encoding, etc

● Eigenwillige Standard Library○ JSON aber kein YAML○ Command Line Flags beeinflusst von Plan 9○ Webserver in 3 Zeilen, aber Slice hat

kein contains()

go’s opinions

● Concurrency-Konzept basiert auf Communicating Sequential Processes○ C.A.R. Hoare 1978

● Goroutines○ Lightweight Threads

● Channels○ Pipelines○ Topics

CodeEndlich...

Hello World

package main

import "fmt"

func main() { name := "World" fmt.Println("Hello " + name + "!")}

Executable

Library

Type Inference

Imports

package main

import ( "fmt" "github.com/julienschmidt/httprouter" "net/http" "log")

func Hello(w http.ResponseWriter, r *http.Request, ps httprouter.Params) { fmt.Fprintf(w, "hello, %s (using %s)!\n", ps.ByName("name"), r.UserAgent())}

func main() { router := httprouter.New() router.GET("/hello/:name", Hello) log.Fatal(http.ListenAndServe(":8080", router))}

Unused Code

package main

import "fmt"import "os"

func main() { result := 7 + 11 fmt.Println("Hello World!")}

Unused import. ERROR.

Unused Code

package main

import "fmt"

func main() { result := 7 + 11 fmt.Println("Hello World!")}

Unused variable. ERROR.

Unused Code

package main

import "fmt"

func main() { fmt.Println("Hello World!")}

Multiple Return Codes

package main

import "fmt"

func Names() (string, string) { return "Eduard", "Breuninger"}

func main() { n1, n2 := Names() fmt.Println(n1, n2)

n3, n4 := Names() fmt.Println(n3)}

Unused variable. ERROR.

Multiple Return Codes

package main

import "fmt"

func Names() (string, string) { return "Eduard", "Breuninger"}

func main() { n1, n2 := Names() fmt.Println(n1, n2)

n3, _ := Names() fmt.Println(n3)}

Multiple Return Codes + No Unused Variables

package main

import "fmt"

func pretendThisIsFancy() (string, error) { return "Eduard", nil}

func main() { name, err := pretendThisIsFancy() if err != nil { // shit what do I do? } fmt.Println(name)}

handling errorshandling errorshandling errors

Types

f(o)

Go bietet keine Klassen. Stattdessen gibt es structs und function receivers.

o.f()

Types

https://play.golang.org/p/aKXkOQNb1YX

type container struct { a int b int}

func multiply(c container) int { return c.a * c.b}

func set(c *container, a, b int) { c.a = a c.b = b}

-------------------------------------------

set(&container, 3, 5)result := multiply(container)

Go bietet keine Klassen. Stattdessen gibt es structs und function receivers.

type container struct { a int b int}

func (c container) multiply() int { return c.a * c.b}

func (c *container) set(a, b int) { c.a = a c.b = b}

-------------------------------------------

container.set(3, 5)result := container.multiply()

Hält Daten

Function ReceiverCall by Value

Call by Reference

Interfaces

https://play.golang.org/p/aKXkOQNb1YX

type multiplier interface { multiply() int}

Ein Interface ist ein Sack voller Methoden. Typen die alle Methoden implementieren, implementieren das Interface.

Interfaces werden implizit implementiert. Es gibt keine explizite “implements” Deklaration.

func print(any multiplier) { fmt.Println("->", any.multiply())}

Sobald ein Typ über ein Interface benutzt wird, überprüft der Compiler, ob der Typ das Interface vollständig implementiert.

Concurrency Demo

go get github.com/sebsprenger/eventdemo

Ein Beispiel mit Goroutines und Channels

generator filter dispatcher

handler

Waitgroup (sync)

handler

handler

Was ich ausgelassen habe...

● Functions als First Class Citizens● Visibility (Exported/Unexported)● Module System

○ Package Management war bisher suboptimal○ Neuer Weg mit go1.11, 1.12, 1.13 (aktuell)

● Unit testing mit eingebauter Code Coverage● Cross-Compilation● und noch vieles mehr...

ÖkosystemNicht nur eine Sprache

Toolchain

● go○ get○ build, install, run, test○ doc○ generate○ fmt○ mod

Community Sites

● golang.org○ tour.golang.org○ play.golang.org

● Go by Example○ gobyexample.com

● Effective Go○ https://golang.org/doc/effective_go.html

● Godoc.org

golangZusammenfassung und Ausblick

Zusammenfassung

● go → Sprache● #golang → Hashtag● Typisierte, (Cross)kompilierte, self-contained● Garbage Collected, Ohne Exceptions● Gebaut für Netzwerk & Multi-Core CPUs● Design-Prinzipien Simplicity & Orthogonality

○ Einfach zu begreifen○ Konsistent im Umgang

Zusammenfassung

● Imports können heruntergeladen werden● Mehrere Return Values● Ungenutzte Imports/Variablen sind Fehler● Ständiges Error Handling● Structs, Functions und Interfaces statt Klassen● Goroutines und Channels für Concurrency

YouTube

https://www.youtube.com/watch?v=CF9S4QZuV30

YouTube

https://www.youtube.com/watch?v=cN_DpYBzKso

Bücher

236 Seiten

Web Apps in Go, mit der Annahme, dass man grund- sätzlich Programmieren kann.

https://www.amazon.de/Level-Your-Web-Apps-Performance-ebook/dp/B00X6GVZ40/

Bücher

280 Seiten

Rezepte aus der echten Welt. Ähnlich wie ein “Effective *” Buch.

https://www.amazon.de/Level-Your-Web-Apps-Performance-ebook/dp/B00X6GVZ40/

Meine Ziele

● Überblick wieso Go ist wie es ist● Vorstellung von ausgewählten Sprachfeatures● Concurrency demonstrieren

Euch Bock machen auf Go

Ziele erreicht? Lasst es mich wissen @sebsprenger

● Code Beispiele● Vorstellung des Ökosystems● Weiterführende Informationen

Euch enablen Go auszuprobieren

‘NUFF SAID