Should I stay or should I "Go"?

Einführung in die Programmiersprache Go: Geschichte, Syntax, Eigenschaften und Paradigmen.

Transcript

1. SHOULD I STAY OR SHOULD I GO? Ralf Wirdemann - kommitment GmbH & Co. KG 1
2. - (RACSignal *)getAllGroupsV2 { RACSignal *signal = [self.communicator getGroupsV2]; return [RACSignal createSignal:^RACDisposable *(id subscriber) [signal subscribeNext:^(NSDictionary *data) { NSManagedObjectContext *context = [PQCoreDataManager sharedManager].managedContext; [PQGroup createOrUpdateWithContext:context data:data]; } error:^(NSError *error){ [subscriber sendError:error]; } completed:^{ [[PQCoreDataManager sharedManager] saveContext]; [subscriber sendCompleted]; }]; return nil; }]; } 2
3. func getAllGroupsV2() { if resp, err := http.Get("http://picue.de/groups"); err != nil panic(err) } var groups []*domain.Group json := resp.Body decoder := json.NewDecoder(json) decode.Decode(&groups) database.CreateGroups(&groups) } 3
4. LESBARKEIT 4
5. MEINE GESCHICHTE 5
6. 1992 int main() { printf("Hello World\n"); return 0; } 6
7. 1994 main() { cout << "Hello World" << endl; } 7
8. 2000 public class HelloWorld { public static void main (String[] args) { System.out.println("Hello World"); } } 8
9. 2008 puts 'Hello World' 9
10. 2016 int main (int argc, const char * argv[]) { NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; NSLog(@"Hello World!"); [pool drain]; return 0; } 10
11. 2016 print("Hello World") 11
12. 2016 func main() { print("Hello World\n") } int main() { printf("Hello World\n"); return 0; } 12
13. 40 JAHRE SPÄTER 13
14. WORUM ES MIR HEUTE GEHT Fragen beantworten, die ich mir selber gestellt habe 10% der Anwesenden wollen Go probieren 14
15. DIE PROGRAMMIERSPRACHE GO Geschichte Tour Eigenscha en Toolchain Wer, wofür, warum? 15
16. GESCHICHTE 2007: Frust Komplextität von Google-So ware Ken Thompson, Rob Pike, Robert Griesemer Idee: Einfache, compilierbare Programmiersprache, die heutigen Rechensystemen gerecht wird, z.B. für einfache skalierbare Netzwerkdienst 2009: Erste öffentliche Version im November 16
17. STATISCH GETYPT s := "Hallo" // string i := 42 // int f := 3.142 // float64 g := 0.867 + 0.5i // complex128 17
18. 25 KEYWORDS break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type continue for import return var 18
19. A TOUR OF GO 19
20. PACKAGES 20
21. $GOROOT/picue/domain/groups.go media.go 21
22. $GOROOT/picue/domain/groups.go media.go package domain type Group struct { ... } 22
23. $GOROOT/picue/domain/groups.go media.go package domain type Group struct { ... } package domain type Media struct { ... } 23
24. FUNCTIONS 24
25. package main func main() { println("Hello") } 25
26. IMPORTS 26
27. package main import "fmt" func main() { fmt.Println("Hello") } 27
28. package main import "fmt" func main() { fmt.Println("Hello") } 28
29. VARIABLEN 29
30. package main import "fmt" var name string func main() { name = "Jax" fmt.Println("Hello, ", name) } 30
31. package main import "fmt" var name string func main() { name = "Jax" fmt.Println("Hello, ", name) } 31
32. package main import "fmt" func main() { name := "Jax" fmt.Println("Hello, ", name) } 32
33. TYPEN 33
34. package main import "fmt" type message string var m message func main() { m = "Hello, Jax" fmt.Println(m) } 34
35. package main import "fmt" type message string var m message func main() { m = "Hello, Jax" fmt.Println(m) } 35
36. package main import "fmt" type message string var m message func main() { m = "Hello, Jax" fmt.Println(m) } 36
37. ZUSAMMENGESETZTE TYPEN 37
38. package main import "fmt" type greeting struct { message string greetee string } func main() { g := greeting{message: "Hello", greetee: "Jax"} fmt.Println(g.message, g.greetee) } 38
39. package main import "fmt" type greeting struct { message string greetee string } func main() { g := greeting{message: "Hello", greetee: "Jax"} fmt.Println(g.message, g.greetee) } 39
40. package main import "fmt" type greeting struct { message string greetee string } func main() { g := greeting{message: "Hello", greetee: "Jax"} fmt.Println(g.message, g.greetee) } 40
41. METHODS 41
42. package main import "fmt" type greeting struct { message string greetee string } func print(g greeting) { fmt.Println(g.message, g.greetee) } func main() { g := greeting{message: "Hello", greetee: "Jax"} print(g) } 42
43. package main import "fmt" type greeting struct { message string greetee string } func print(g greeting) { fmt.Println(g.message, g.greetee) } func main() { g := greeting{message: "Hello", greetee: "Jax"} print(g) } 43
44. package main import "fmt" type greeting struct { message string greetee string } func print(g greeting) { fmt.Println(g.message, g.greetee) } func main() { g := greeting{message: "Hello", greetee: "Jax"} print(g) } 44
45. package main import "fmt" type greeting struct { message string greetee string } func (g greeting) print() { fmt.Println(g.message, g.greetee) } func main() { g := greeting{message: "Hello", greetee: "Jax"} g.print() } 45
46. package main import "fmt" type greeting struct { message string greetee string } func (g greeting) print() { fmt.Println(g.message, g.greetee) } func main() { g := greeting{message: "Hello", greetee: "Jax"} g.print() } 46
47. package main import "fmt" type greeting struct { message string greetee string timesPrinted int } func (g greeting) print() { fmt.Println(g.message, g.greetee) g.timesPrinted++ } func main() { g := greeting{message: "Hello", greetee: "Jax"} g.print() fmt.Printf("times printed: %d", g.timesPrinted) } 47
48. package main import "fmt" type greeting struct { message string greetee string timesPrinted int } func (g greeting) print() { fmt.Println(g.message, g.greetee) g.timesPrinted++ } func main() { g := greeting{message: "Hello", greetee: "Jax"} g.print() fmt.Printf("times printed: %d", g.timesPrinted) } 48
49. package main import "fmt" type greeting struct { message string greetee string timesPrinted int } func (g greeting) print() { fmt.Println(g.message, g.greetee) g.timesPrinted++ } func main() { g := greeting{message: "Hello", greetee: "Jax"} g.print() fmt.Printf("times printed: %d", g.timesPrinted) } 49
50. package main import "fmt" type greeting struct { message string greetee string timesPrinted int } func (g greeting) print() { fmt.Println(g.message, g.greetee) g.timesPrinted++ } func main() { g := greeting{message: "Hello", greetee: "Jax"} g.print() fmt.Printf("times printed: %d", g.timesPrinted) } 50
51. package main import "fmt" type greeting struct { message string greetee string timesPrinted int } func (g greeting) print() { fmt.Println(g.message, g.greetee) g.timesPrinted++ } func main() { g := greeting{message: "Hello", greetee: "Jax"} g.print() fmt.Printf("times printed: %d", g.timesPrinted) => 0 } 51
52. POINTER 52
53. package main import "fmt" func inc(px *int) { *px++ } func main() { x := 1 p := &x inc(p) fmt.Printf("x: %d", *p) } 53
54. package main import "fmt" func inc(px *int) { *px++ } func main() { x := 1 p := &x inc(p) fmt.Printf("x: %d", *p) } 54
55. package main import "fmt" func inc(px *int) { *px++ } func main() { x := 1 p := &x inc(p) fmt.Printf("x: %d", *p) } 55
56. package main import "fmt" func inc(px *int) { *px++ } func main() { x := 1 p := &x inc(p) fmt.Printf("x: %d", *p) } 56
57. package main import "fmt" func inc(px *int) { *px++ } func main() { x := 1 p := &x inc(p) fmt.Printf("x: %d", *p) } 57
58. package main import "fmt" func inc(px *int) { *px++ } func main() { x := 1 p := &x inc(p) fmt.Printf("x: %d", *p) } 58
59. package main import "fmt" func inc(px *int) { *px++ } func main() { x := 1 p := &x inc(p) fmt.Printf("x: %d", *p) => x: 2 } 59
60. POINTER RECEIVER 60
61. package main import "fmt" type greeting struct { message string greetee string timesPrinted int } func (g *greeting) print() { fmt.Println(g.message, g.greetee) g.timesPrinted++ } func main() { g := &greeting{message: "Hello", greetee: "Jax"} g.print() fmt.Printf("times printed: %d", g.timesPrinted) } 61
62. package main import "fmt" type greeting struct { message string greetee string timesPrinted int } func (g *greeting) print() { fmt.Println(g.message, g.greetee) g.timesPrinted++ } func main() { g := &greeting{message: "Hello", greetee: "Jax"} g.print() fmt.Printf("times printed: %d", g.timesPrinted) } 62
63. package main import "fmt" type greeting struct { message string greetee string timesPrinted int } func (g *greeting) print() { fmt.Println(g.message, g.greetee) g.timesPrinted++ } func main() { g := &greeting{message: "Hello", greetee: "Jax"} g.print() fmt.Printf("times printed: %d", g.timesPrinted) } 63
64. package main import "fmt" type greeting struct { message string greetee string timesPrinted int } func (g *greeting) print() { fmt.Println(g.message, g.greetee) g.timesPrinted++ } func main() { g := &greeting{message: "Hello", greetee: "Jax"} g.print() fmt.Printf("times printed: %d", g.timesPrinted) } 64
65. package main import "fmt" type greeting struct { message string greetee string timesPrinted int } func (g *greeting) print() { fmt.Println(g.message, g.greetee) g.timesPrinted++ } func main() { g := &greeting{message: "Hello", greetee: "Jax"} g.print() fmt.Printf("times printed: %d", g.timesPrinted) } 65
66. package main import "fmt" type greeting struct { message string greetee string timesPrinted int } func (g *greeting) print() { fmt.Println(g.message, g.greetee) g.timesPrinted++ } func main() { g := &greeting{message: "Hello", greetee: "Jax"} g.print() fmt.Printf("times printed: %d", g.timesPrinted) => 1 } 66
67. INTERFACES 67
68. type Printable interface { print() string } type greeting struct { message string greetee string } func (g *greeting) print() string { return fmt.Sprintf("", g.message, g.greetee) } func printOnConsole(printable Printable) { fmt.Printf("=> %s", printable.print()); } func main() { g := &greeting{message: "Hello", greetee: "Jax"} printOnConsole(g) } 68
69. type Printable interface { print() string } type greeting struct { message string greetee string } func (g *greeting) print() string { return fmt.Sprintf("", g.message, g.greetee) } func printOnConsole(printable Printable) { fmt.Printf("=> %s", printable.print()); } func main() { g := &greeting{message: "Hello", greetee: "Jax"} printOnConsole(g) } 69
70. type Printable interface { print() string } type greeting struct { message string greetee string } func (g *greeting) print() string { return fmt.Sprintf("", g.message, g.greetee) } func printOnConsole(printable Printable) { fmt.Printf("=> %s", printable.print()); } func main() { g := &greeting{message: "Hello", greetee: "Jax"} printOnConsole(g) } 70
71. type Printable interface { print() string } type greeting struct { message string greetee string } func (g *greeting) print() string { return fmt.Sprintf("", g.message, g.greetee) } func printOnConsole(printable Printable) { fmt.Printf("=> %s", printable.print()) } func main() { g := &greeting{message: "Hello", greetee: "Jax"} printOnConsole(g) } 71
72. type Printable interface { print() string } type greeting struct { message string greetee string } func (g *greeting) print() string { return fmt.Sprintf("", g.message, g.greetee) } func printOnConsole(printable Printable) { fmt.Printf("=> %s", printable.print()) } func main() { g := &greeting{message: "Hello", greetee: "Jax"} printOnConsole(g) } 72
73. type Printable interface { print() string } type greeting struct { message string greetee string } func (g *greeting) print() string { return fmt.Sprintf("", g.message, g.greetee) } func printOnConsole(printable Printable) { fmt.Printf("=> %s", printable.print()) } func main() { g := &greeting{message: "Hello", greetee: "Jax"} printOnConsole(g) } 73
74. type Printable interface { print() string } type greeting struct { message string greetee string } func (g *greeting) print() string { return fmt.Sprintf("", g.message, g.greetee) } func printOnConsole(printable Printable) { fmt.Printf("=> %s", printable.print()); } func main() { g := &greeting{message: "Hello", greetee: "Jax"} printOnConsole(g) } 74
75. type Printable interface { print() string } type greeting struct { message string greetee string } func (g *greeting) print() string { return fmt.Sprintf("", g.message, g.greetee) } func printOnConsole(printable Printable) { fmt.Printf("=> %s", printable.print()); } func main() { g := &greeting{message: "Hello", greetee: "Jax"} printOnConsole(g) } 75
76. GO ONE PAGER Packages Typen Interfaces Funktionen Pointer 76
77. package main import "fmt" type Dog struct { name string timesBarked int } type Animal interface { bark() } func (d *Dog) bark() { fmt.Printf("I am %s", d.name) d.timesBarked++ } func sayHello(animal Animal) { animal.bark() } func main() { kalle := &Dog{name: "Kalle"} sayHello(kalle) } 77
78. package main import "fmt" type Dog struct { name string timesBarked int } type Animal interface { bark() } func (d *Dog) bark() { fmt.Printf("I am %s", d.name) d.timesBarked++ } func sayHello(animal Animal) { animal.bark() } func main() { kalle := &Dog{name: "Kalle"} sayHello(kalle) } 78
79. package main import "fmt" type Dog struct { name string timesBarked int } type Animal interface { bark() } func (d *Dog) bark() { fmt.Printf("I am %s", d.name) d.timesBarked++ } func sayHello(animal Animal) { animal.bark() } func main() { kalle := &Dog{name: "Kalle"} sayHello(kalle) } 79
80. package main import "fmt" type Dog struct { name string timesBarked int } type Animal interface { bark() } func (d *Dog) bark() { fmt.Printf("I am %s", d.name) d.timesBarked++ } func sayHello(animal Animal) { animal.bark() } func main() { kalle := &Dog{name: "Kalle"} sayHello(kalle) } 80
81. package main import "fmt" type Dog struct { name string timesBarked int } type Animal interface { bark() } func (d *Dog) bark() { fmt.Printf("I am %s", d.name) d.timesBarked++ } func sayHello(animal Animal) { animal.bark() } func main() { kalle := &Dog{name: "Kalle"} sayHello(kalle) } 81
82. package main import "fmt" type Dog struct { name string timesBarked int } type Animal interface { bark() } func (d *Dog) bark() { fmt.Printf("I am %s", d.name) d.timesBarked++ } func sayHello(animal Animal) { animal.bark() } func main() { kalle := &Dog{name: "Kalle"} sayHello(kalle) } 82
83. package main import "fmt" type Dog struct { name string timesBarked int } type Animal interface { bark() } func (d *Dog) bark() { fmt.Printf("I am %s", d.name) d.timesBarked++ } func sayHello(animal Animal) { animal.bark() } func main() { kalle := &Dog{name: "Kalle"} sayHello(kalle) } 83
84. GO - SPRACHEIGENSCHAFTEN 84
85. KAPSELUNG 85
86. VERERBUNG 86
87. JAVA public class A { public void print() { ... } } public class B extends A { } B b = new B(); b.print(); 87
88. GO type A struct { a int } type B struct { A } func (a A) print() { ... } b := B{} b.print() // Not allowed in Java 88
89. GO type A struct { a int } type B struct { A } func (a A) print() { ... } b := B{} b.print() // Not allowed in Java 89
90. GO type A struct { a int } type B struct { A } func (a A) print() { ... } b := B{} b.print() // Not allowed in Java 90
91. GO type A struct { a int } type B struct { A } func (a A) print() { ... } b := B{} b.print() // Not allowed in Java 91
92. GO type A struct { a int } type B struct { A } func (a A) print() { ... } b := B{} b.print() // Not allowed in Java 92
93. POLYMORPHISMUS 93
94. JAVA public class A { public void print() { ... } } public class B extends A { } List<A> l = new ArrayList<>(); l.add(new B()); 94
95. GO type A struct { a int } type B struct { A } list := [2]A{} list[0] = A{} list[1] = B{} // doesn't compile 95
96. GO type A struct { a int } type B struct { A } list := [2]A{} list[0] = A{} list[1] = B{} // doesn't compile 96
97. GO type A struct { a int } type B struct { A } list := [2]A{} list[0] = A{} list[1] = B{} // doesn't compile 97
98. GO type A struct { a int } type B struct { A } list := [2]A{} list[0] = A{} list[1] = B{} // doesn't compile 98
99. GO type A struct { a int } type B struct { A } list := [2]A{} list[0] = A{} list[1] = B{} // doesn't compile 99
100. POLYMORPHISMUS VIA INTERFACES 100
101. type Animal interface { Talk() string } ... kalle := Dog{"Kalle"} felix := Cat{"Felix"} animals := [2]Animal{kalle, felix} for _, v := range animals { fmt.Printf("Hey, %s\n", v.Talk()) } 101
102. type Animal interface { Talk() string } ... kalle := Dog{"Kalle"} felix := Cat{"Felix"} animals := [2]Animal{kalle, felix} for _, v := range animals { fmt.Printf("Hey, %s\n", v.Talk()) } 102
103. type Animal interface { Talk() string } ... kalle := Dog{"Kalle"} felix := Cat{"Felix"} animals := [2]Animal{kalle, felix} for _, v := range animals { fmt.Printf("Hey, %s\n", v.Talk()) } 103
104. type Animal interface { Talk() string } ... kalle := Dog{"Kalle"} felix := Cat{"Felix"} animals := [2]Animal{kalle, felix} for _, v := range animals { fmt.Printf("Hey, %s\n", v.Talk()) } 104
105. type Animal interface { Talk() string } ... kalle := Dog{"Kalle"} felix := Cat{"Felix"} animals := [2]Animal{kalle, felix} for _, v := range animals { fmt.Printf("Hey, %s\n", v.Talk()) } 105
106. type Animal interface { Talk() string } ... kalle := Dog{"Kalle"} felix := Cat{"Felix"} animals := [2]Animal{kalle, felix} for _, v := range animals { fmt.Printf("Hey, %s\n", v.Talk()) } 106
107. FUNKTIONALE PROGRAMMIERUNG 107
108. func main() { f := func(x int) int { return x * x } result := f(2) print(result) } 108
109. func main() { f := func(x int) int { return x * x } result := f(2) print(result) } 109
110. func foo(fn func(x int) int) int { return fn(2) } func main() { f := func(x int) int { return x * x } result := foo(f) print(result) } 110
111. func foo(fn func(x int) int) int { return fn(2) } func main() { f := func(x int) int { return x * x } result := foo(f) print(result) } 111
112. type myfunction func(x int) int func foo(fn myfunction) int { return fn(2) } func main() { f := func(x int) int { return x * x } result := foo(f) print(result) } 112
113. type myfunction func(x int) int func foo(fn myfunction) int { return fn(2) } func main() { f := func(x int) int { return x * x } result := foo(f) print(result) } 113
114. CONCURRENCY 114
115. func sum(s []int) int { sum := 0 for _, v := range s { sum += v } return sum } println("sum: ", sum(values)) // sum: 124999999750000000 115
116. func sum(s []int) int { sum := 0 for _, v := range s { sum += v } return sum } println("sum: ", sum(values)) // sum: 124999999750000000 116
117. func sum(s []int) int { sum := 0 for _, v := range s { sum += v } return sum } s1 := sum(values[0:size/2-1]) s2 := sum(values[size/2-1:]) println("sum: ", s1 + s2) // sum: 124999999750000000 117
118. func sum(s []int) int { sum := 0 for _, v := range s { sum += v } return sum } s1 := sum(values[0:size/2-1]) s2 := sum(values[size/2-1:]) println("sum: ", s1 + s2) // sum: 124999999750000000 118
119. func sum(s []int) int { sum := 0 for _, v := range s { sum += v } return sum } s1 := sum(values[0:size/2-1]) s2 := sum(values[size/2-1:]) println("sum: ", s1 + s2) // sum: 124999999750000000 119
120. func sum(s []int, c chan int) { sum := 0 for _, v := range s { sum += v } c <- sum // send result to channel } c := make(chan int) go sum(values[0:size/2-1], c) go sum(values[size/2-1:], c) s1, s2 := <-c, <-c // receive value from channel println("sum: ", s1 + s2) // sum: 124999999750000000 120
121. func sum(s []int, c chan int) { sum := 0 for _, v := range s { sum += v } c <- sum // send result to channel } c := make(chan int) go sum(values[0:size/2-1], c) go sum(values[size/2-1:], c) s1, s2 := <-c, <-c // receive value from channel println("sum: ", s1 + s2) // sum: 124999999750000000 121
122. func sum(s []int, c chan int) { sum := 0 for _, v := range s { sum += v } c <- sum // send result to channel } c := make(chan int) go sum(values[0:size/2-1], c) go sum(values[size/2-1:], c) s1, s2 := <-c, <-c // receive value from channel println("sum: ", s1 + s2) // sum: 124999999750000000 122
123. func sum(s []int, c chan int) { sum := 0 for _, v := range s { sum += v } c <- sum // send result to channel } c := make(chan int) go sum(values[0:size/2-1], c) go sum(values[size/2-1:], c) s1, s2 := <-c, <-c // receive value from channel println("sum: ", s1 + s2) // sum: 124999999750000000 123
124. func sum(s []int, c chan int) { sum := 0 for _, v := range s { sum += v } c <- sum // send result to channel } c := make(chan int) go sum(values[0:size/2-1], c) go sum(values[size/2-1:], c) s1, s2 := <-c, <-c // receive value from channel println("sum: ", s1 + s2) // sum: 124999999750000000 124
125. ZUSAMMENFASSUNG Komposition statt Vererbung Interfaces Polymorphismus Funktionale Programmierung Concurrency 125
126. GO TOOL CHAIN 126
127. DER GO WORKSPACE $GOPATH/src /bin /pkg 127
128. EIN WORKSPACE, VIELE PROJEKTE $GOPATH/src/bitbucket.org/rwirdemann/hello/main.go /hello/domain/models.go /picue/main.go /picue/controllers/grouplist.go /bin/hello picue /pkg/linux_amd64/bitbucket.org/rwirdemann/hello/domain.a 128
129. EIN TOOL: GO go run src/bitbucket.org/rwirdemann/hello/main.go go install bitbucket.org/rwirdemann/hello cd $GOPATH/src/bitbucket.org/rwirdemann/hello/domain go test go test groups_test.go 129
130. DEPENDENCY MANAGEMENT $GOPATH/src/github.com/ /golang.org ... $ go get github.com/go-sql-driver/mysql $GOPATH/src/github.com/go-sql-driver/mysql import "github.com/go-sql-driver/mysql" 130
131. WEITERE TOOLS gofmt goimport godef golint gocode ... 131
132. WER NUTZT GO? Google Docker Wunderkinder Booking.com Crashlytics Dropbox Soundcloud 132
133. WOFÜR GO? 133
134. APIS UND MICROSERVICES 134
135. WARUM GO? 135
136. PRODUKTIVITÄT Erlernbarkeit Standards Einheitlicher Workspace Lesbarkeit 136
137. TYPSICHERHEIT Map<String, List<Note>> sections = new HashMap<String, List<Note>>( Map<String, List<Note>> sections = new HashMap<>(); sections := make(map[string][]Note) 137
138. PERFORMANCE 138
139. DEPLOYMENT 139
140. WORLD CLASS STANDARD LIBRARY 140
141. NET/HTTP 141
142. package main import ( "fmt" "net/http" ) func handleRequest(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello, World\n") } func main() { http.HandleFunc("/hello", handleRequest) http.ListenAndServe(":8080", nil) } 142
143. package main import ( "fmt" "net/http" ) func handleRequest(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello, World\n") } func main() { http.HandleFunc("/hello", handleRequest) http.ListenAndServe(":8080", nil) } 143
144. package main import ( "fmt" "net/http" ) func handleRequest(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello, World\n") } func main() { http.HandleFunc("/hello", handleRequest) http.ListenAndServe(":8080", nil) } 144
145. package main import ( "fmt" "net/http" ) func handleRequest(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello, World\n") } func main() { http.HandleFunc("/hello", handleRequest) http.ListenAndServe(":8080", nil) } 145
146. package main import ( "fmt" "net/http" ) func handleRequest(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello, World\n") } func main() { http.HandleFunc("/hello", handleRequest) http.ListenAndServe(":8080", nil) } 146
147. EINFACHHEIT Reduzierte Syntax Sprachstabilität als Feature Nur ein Weg Mindset 147
148. WAS NERVT? 148
149. ERROR HANDLING 149
150. func create(a *Activity) { var res Result var err Error res, err = DB.Exec("insert ...", a.Name) if err != nil { panic(err) } var id int64 id, err = res.LastInsertId() if err != nil { panic(err) } activity.Id = id ... } 150
151. NO RAILS HTTP / JSON Support ist top gobuffalo 151
152. POINTER Waren wir froh, als wir sie los waren NullPointerException Immutability for free Entscheide dich: by value oder by reference Keine Pointer-Arithmetik Garbage Collection 152
153. KEINE GENERICS List<String> l = new ArrayList<>(); Map<String, Media> m = new HashMap<>(); l := [5]string m := make(map[string]Media) 153
154. DEPENDENCY MANAGEMENT $GOPATH/src/bitbucket.org/rwirdemann/gornale picue github.com/go-sql-driver/mysql 154
155. KEINE KLASSEN Keine Vererbung Fehlende Modellierungsgrundlage 155
156. WIE GEHTS WEITER? Mein nächstes Go-Projekt Workshop Schulung Vortrag Cooles Freizeitprojekt 156
157. RESOURCEN The Go Programming Language https://tour.golang.org https://gobyexample.com/ 157
158. HEY HO, LET'S GO VIELEN DANK! ralf.wirdemann@kommitment.biz 158