Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

Ein Gopher im Netz

170 views

Published on

JAX 2019 - Einführung in Google Go

(Introduction into Google Go)

Published in: Software
  • DOWNLOAD FULL BOOKS, INTO AVAILABLE FORMAT ......................................................................................................................... ......................................................................................................................... 1.DOWNLOAD FULL. PDF EBOOK here { https://tinyurl.com/yxufevpm } ......................................................................................................................... 1.DOWNLOAD FULL. EPUB Ebook here { https://tinyurl.com/yxufevpm } ......................................................................................................................... 1.DOWNLOAD FULL. doc Ebook here { https://tinyurl.com/yxufevpm } ......................................................................................................................... 1.DOWNLOAD FULL. PDF EBOOK here { https://tinyurl.com/yxufevpm } ......................................................................................................................... 1.DOWNLOAD FULL. EPUB Ebook here { https://tinyurl.com/yxufevpm } ......................................................................................................................... 1.DOWNLOAD FULL. doc Ebook here { https://tinyurl.com/yxufevpm } ......................................................................................................................... ......................................................................................................................... ......................................................................................................................... .............. Browse by Genre Available eBooks ......................................................................................................................... Art, Biography, Business, Chick Lit, Children's, Christian, Classics, Comics, Contemporary, Cookbooks, Crime, Ebooks, Fantasy, Fiction, Graphic Novels, Historical Fiction, History, Horror, Humor And Comedy, Manga, Memoir, Music, Mystery, Non Fiction, Paranormal, Philosophy, Poetry, Psychology, Religion, Romance, Science, Science Fiction, Self Help, Suspense, Spirituality, Sports, Thriller, Travel, Young Adult,
       Reply 
    Are you sure you want to  Yes  No
    Your message goes here
  • Be the first to like this

Ein Gopher im Netz

  1. 1. Ein Gopher im Netz Frank Müller / Loodse GmbH
  2. 2. Vorstellung • Frank Müller • Oldenburg • Baujahr 1965 • Senior Solution Engineer
 bei Loodse GmbH • Im Netz als @themue zu finden
  3. 3. Kurzüberblick
  4. 4. • Go ist langweilig • Go folgt keinem klaren Paradigma • Go bietet keine esoterischen Features • Go bietet nichts wirklich Neues • Go ist nicht perfekt • Go beinhaltet Stolpersteine
  5. 5. ABER • Go ist einfach (Language Specification nur eine HTML Seite) • Go bringt eine umfangreiche Bibliothek mit sich • Go kompiliert sehr schnell in ein Binary • Go beherrscht Cross-Compiling • Go verfügt über Garbage Collection • Go führt sehr schnell aus • Go ist pragmatisch
  6. 6. –Oscar Wilde „It’s better to have a permanent income than to be fascinating.“
  7. 7. Historie
  8. 8. Historie • Start Ende 2007 aus Frust • FAQ: „One had to choose either efficient compilation, efficient execution, or ease of programming; all three were not available in the same mainstream language.“ • Beginn der Entwicklung Mitte 2008 • Erste öffentliche Vorversion im November 2009 • Version 1.0 im März 2012
  9. 9. –Rob Pike „Go aims to combine the safety and performance of a statically typed compiled language with the expressiveness and convenience of a dynamically typed interpreted language. It also aims to be suitable for modern systems – large scale – programming.“
  10. 10. Das Team • Rob Pike • Ken Thompson • Robert Griesemer • Russ Cox • Ian Lance Taylor • Und weitere ...
  11. 11. Keine Unbekannten • Ken Thompson — Multics, Unix, B, Plan 9, ed, UTF-8, etc. sowie Turing Award • Rob Pike — Unix, Plan 9, Inferno, Limbo, UTF-8, etc. • Robert Griesemer — Strongtalk, Java HotSpot VM, V8 JavaScript Engine
  12. 12. Fortschritt • 2014 wurde der der Gopher das Maskottchen von Go; entworfen von Renée French, der Ehefrau von Rob Pike • Alle 6 Monate erscheint ein neues Release • Aktuell Version 1.12.5 • Versprechen der Sprachkompatibilität gleicher Hauptversionen • Go 2 in Diskussion
  13. 13. Werkzeuge
  14. 14. Drei Binaries • go — Wichtigstes Werkzeug mit vielen Subcommands • gofmt — Einheitliche Formatierung der Go Quellen • godoc — Generierung von Dokumentation aus Kommentaren
  15. 15. go Subcommands (Auszug) • build — Compiling der Quellen • fmt — Formattierung der Quellen • get — Packages herunterladen und installieren • install — Compiling und Installation der Quellen • mod — Verwaltung von Modulen • test — Durchführung der Unit Tests • vet — Bericht über gängige Fehler
  16. 16. go mod Subcommands (Auszug) • download — Download von Modulen in lokalen Cache • init — Initialisierung eines Moduls im aktuellen Verzeichnis • tidy — Bereinigung der Abhängigkeiten • vendor — Vendorize von Abhängigkeiten • why — Erläuterung von Abhängigkeiten
  17. 17. Die Sprache Go
  18. 18. Orientierung in Packages • Code immer in Packages • Ein oder mehrere Dateien pro Package in einem Verzeichnis • Sonderrollen • main wird zu ausführbarem Programm • <name>_test wird zu Unit Test von Package <name> • Packages lassen sich hierarchisch schachteln
  19. 19. // main wird zu Programm mit dem Namen des Verzeichnisses. package main // Einstieg in das Programm. func main() { println("Hello, World!") }
  20. 20. Import von Packages • Import als erste Anweisung nach dem Package Statement • Externe Packages enthalten Domain und Pfad • Eigene Domains mit Code auf z.B. GitHub sind via Meta Tags in einem lokalen HTML-Dokument ebenfalls möglich • Package-Name als Präfix für Namensräume • Alias kann gegen Namensgleichheit gesetzt werden • Export durch Großschreibung, sonst package private
  21. 21. package info import ( "fmt" "github.com/moby/moby/volume" myvolume "github.com/myname/myproject/volume" ) func Info() string { return fmt.Sprintf("name %v / size %v", volume.DefaultDriverName, myvolume.DefaultSize()) }
  22. 22. Funktionen • Schlüsselwort func • Mit Namen, anonym oder als Methode eigener Typen • Beliebige Anzahl Parameter, letzter kann variadisch sein • Beliebige Anzahl Rückgabewerte ohne und mit Namen • Rückgabe mit Schlüsselwort return
  23. 23. // Mul multipliziert f mit einer beliebigen Anzahl // Integer. func Mul(f int, vs ...int) int { r := f for _, v := range vs { r *= v } return r }
  24. 24. // Div dividiert f ganzzahlig durch eine beliebige Anzahl // Integer. func Div(f int, vs ...int) (int, error) { r := f for _, v := range vs { if v == 0 { return 0, errors.New("division by zero") } r /= v } return r, nil }
  25. 25. // Server ist ein Typ mit privaten Feldern. type Server struct { port int ... } // Option ist eine Funktion, die auf einem Server operiert. type Option func(s *Server)
  26. 26. // Port liefert eine Option zum Setzen des Felds port // zurück. func Port(port int) Option { return func(s *Server) { s.port = port } }
  27. 27. // New erzeugt einen Server. Optionen sind ... optional. ;) func New(opts ...Option) *Server { s := &Server{ port: 12345, // Standardwert. ... } for _, opt := range opts { opt(s) } return s }
  28. 28. Typenlehre
  29. 29. Einfache Typen • int / int8 / int16 / int32 / rune / int64 • uint / uint8 / byte / uint16 / uint32 / uint64 • float32 / float64 • complex64 / complex128 • bool • string
  30. 30. Zusammengesetzte Typen • Arrays und Slices • Maps • Structs • Funktionen • Interfaces • Error • Channel
  31. 31. type StringProducer func() []string func (sp StringProducer) Len() int { return len(sp()) } // Sizer definiert in meinem Package, was ich von einem // Typ benötige. type Sizer interface { Len() int } func SizePrinter(sizer Sizer) { ... }
  32. 32. type Honk interface { Honk() string } // Car bettet Honk ein, geht mit Structs und Interfaces. type Car struct { Honk motor *Motor ... } myCar.Honk()
  33. 33. // Handler in Package net/http definiert einen Handler für // Web Requests. type Handler interface { ServeHTTP(ResponseWriter, *Request) } // ListenAndServe startet den Server mit einem Handler. func ListenAndServe(addr string, handler Handler) error
  34. 34. // HandlerFunc vereinfach den Handler zu nur einer Funktion. type HandlerFunc func(ResponseWriter, *Request) // ServeHTTP implementiert den Handler und führt nur die // Handler-Funktion aus. func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) { f(w, r) }
  35. 35. // ServeMux verteilt auf Handler nach Pfaden. type ServeMux struct { ... } func (mux *ServeMux) Handle(pattern string, handler Handler) { ... } // ServeHTTP implementiert Handler. func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) { ... }
  36. 36. Von einfachem Interface zu mehr • Multiplexer für HTTP Methoden • Multiplexer für Schachtelung bei RESTful APIs • Schachtelung für Trennung von Authentisierung/Autorisierung via JSON Web Tokens o.ä.
  37. 37. Variablen explizit und implizit • Mit Deklaration via var oder mit Zuweisung durch := • Typisierung explizit oder implizit • var kennt beides, := ist immer implizit • Zuweisung mit =
  38. 38. var s1 string // Deklaration s1 = "Hello" // Zuweisung var s2 string = "World" // Explizit mit Zuweisung var s3 = s1 + ", " + s2 // Implizit mit Zuweisung s4 := s3 + "!" // Deklaration implizit mit // Zuweisung
  39. 39. Kontrolle behalten
  40. 40. Bedingungen • Mit if oder switch für logische Bedingungen • Mit select für Channel • switch und select kennen default an beliebiger Stelle • break nicht notwendig • switch verfügt über fallthrough für die Ausführung der Folgebedingung
  41. 41. if x > y { x, y = y, x } if myFunctionReturnsTrue() { fmt.Println("Juchu!") } else { fmt.Println("Schade") }
  42. 42. switch x { case 1, 2, 3: fmt.Println("1 bis 3") // Verpönte Weiterverarbeitung! fallthrough case 4, 5, 6: fmt.Println("4 bis 6") default: fmt.Println("Keine Ahnung") }
  43. 43. // Abarbeitung von oben nach unten, aber default immer nur // wenn nichts passt. switch { case x < 0: fmt.Println("Kleiner als 0") default: fmt.Println("Ha! Genau 0") case x > 0: fmt.Println("Größer als 0") }
  44. 44. select { case <-ctx.Done() return ctx.Err() case job := <-jobs: if err := job(); err != nil { log.Printf("job failed: %v", err) } case <-time.Tick(5 * time.Second): log.Printf("I'm waiting ...") }
  45. 45. Schleifen • Schlüsselwort for • Verschiedene Formen der Bedingungen • Vorzeitige Fortsetzung über continue • Vorzeitiges Verlassen über break • Label für geschachtelte Schleifen • Arrays, Slices, Maps und Channel können mit range iteriert werden
  46. 46. for { ... if shallLeave { break } } i := 0 for i < 2019 { ... i++ }
  47. 47. for i := 0; i < 2019; i++ { if i % 2 == 0 { continue } ... } visitors := visitorsByConference("JAX 2019") for i, visitor := range visitors { fmt.Printf("Besucher %d ist %sn", i, visitor.Name) }
  48. 48. Nebenläufigkeit
  49. 49. Nebenläufigkeit • Leichtgewichtige Funktionen (Goroutinen) im Thread Pool • Schnelle Kontextwechsel • Kommunikation über typisierte Channel • Abfrage mehrerer Channel gleichzeitig über select • Start mit Schlüsselwort go • Gibt keine ID o.ä. zurück
  50. 50. –Rob Pike „In programming, concurrency is the composition of independently executing processes, while parallelism is the simultaneous execution of (possibly related) computations. Concurrency is about dealing with lots of things at once. Parallelism is about doing lots of things at once.“
  51. 51. Muster
  52. 52. • Einfacher Funktionsablauf im Hintergrund • „Mach mal.“ • Dito mit Rückgabe eines Ergebnisses über einen Channel • „Mach mal und bring mir dann das Ergebnis.“ • Kontinuierlicher Empfang zu verarbeitender Daten • „Kümmere dich um alle meine Aufträge.“ • Dito mit serialisiertem Zugriff auf einen privaten Zustand • „Sei mein schlauer Kollege.“
  53. 53. Client / Server Client Client Client Server
  54. 54. Aufgabenverteilung Client Client Client Dispatcher Worker Worker Worker
  55. 55. Map / Reduce Map Reduce Map Map Reduce Map Reduce
  56. 56. Netze von Goroutinen Goroutine Goroutine Goroutine Goroutine Goroutine Goroutine Goroutine Goroutine Goroutine
  57. 57. Server als Beispiel
  58. 58. type Op func() // Calc ist ein Taschenrechner mit einem Wert als Zustand. type Calc struct { cancel context.CancelFunc ops chan Op value float64 }
  59. 59. func New(ctx cancel.Context) *Calc { c := &Calc{ ops: make(chan Op, 1), value: 0.0, } ctx, c.cancel = context.WithCancel(ctx) go c.backend(ctx) return c }
  60. 60. func (c *Calc) Stop() { c.cancel() }
  61. 61. func (c *Calc) Add(v float64) (r float64) { wait := make(chan struct{}) c.ops <- func() { c.value += v r = c.value close(wait) log.Printf("calc added %f, new value is %f", v, r) } <-wait return }
  62. 62. func (c *Calc) Div(v float64) (r float64, err error) { if v == 0 { return 0.0, errors.New("divide by zero") } wait := make(chan struct{}) c.ops <- func() { c.value /= v r = c.value close(wait) log.Printf("calc divided %f, new value is %f", v, r) } <-wait return }
  63. 63. func (c *Calc) backend(ctx context.Context) { for { select { case <-ctx.Done(): return case op := <-c.ops: op() } } }
  64. 64. Weiteres
  65. 65. Aufschieben • Funktionen können im Ablauf mit defer gestapelt werden • Werden rückwärts beim Verlassen der umgebenden Funktion ausgeführt • Praktisch für Aufräumarbeiten, zum Beispiel Schließen geöffneter Dateien
  66. 66. file, err := ioutil.TempFile("/tmp", "jax2019") if err != nil { return fmt.Errorf("failed to open temp file: %v", err) } defer file.Close() writer := bufio.NewWriter(file) defer writer.Flush() writer.WriteString("JAX 2019n") writer.WriteString("Ein Gopher im Netzn")
  67. 67. Fehlerbehandlung • Keine Exceptions • Fehlertyp error als letzter Rückgabewert • Interface mit Methode Error() string • panic() für echte Ausnahmesituationen • Kann mit recover() aufgefangen werden
  68. 68. func CanBreakHard(x int) (err error) { defer func() { if r := recover(); r != nil { err = fmt.Errorf("panic: %v", r) } }() ... if veryBadCondition { panic("have a very, yes, very, very bad condition") } return nil }
  69. 69. Bibliothek
  70. 70. Daten • Archivierung (tar, zip) • Komprimierung (bzip2, flate, gzip, lzw, zlib) • Encoding (ASN.1, CSV, JSON, XML) • Strings, Text, reguläre Ausdrücke • Text Templates • Time • Unicode
  71. 71. Netz • Crypto (AES, Cipher, ECDSA, HMAC, RSA, SHA512, TLS) • Netzwerk • HTTP Client und Server • HTML Templates • JSON-RPC • SMTP
  72. 72. Und vieles mehr ... • I/O • SQL Datenbanken • Synchronisation (Mutex, Once, WaitGroup), Context • Images • Reflection • Unit Tests
  73. 73. Zusammenfassung
  74. 74. Paradigmenmix ohne Overload • Sequentielle Abfolge von Anweisungen ➟ imperativ • Funktionstypen, Closures ➟ funktional • Methoden, Interfaces, Komposition ➟ objekt-orientiert • Goroutinen, Channels ➟ nebenläufig
  75. 75. Fast wie Scripting • Einfache Syntax • Leichtgewichtiges Typenmodell • Wenige Schlüsselworte • Schnelle Kompilation erlaubt schnelle Tests • Aber: Manchmal mehrere Lösungswege möglich • Nutzung etablierter Konventionen hilft
  76. 76. Einfache Nebenläufigkeit • Prinzipiell nur Funktionen • Flexible Kommunikation • Weitere Hilfen zur Synchronisation • Aber: Kein Schutz vor gleichzeitigem Zugriff auf Variablen • Aber: Kein Schutz vor Locks und Races • Tools helfen, ansonsten Verantwortung des Entwicklers
  77. 77. Vielen Dank

×