Impossible Go - GopherCon UK 2019

You know how to code in Go, don’t you? Let’s see!

This talk shows Go snippets that seem easy, difficult, wrong or impossible. Through these different Go constructs and code, we not only have fun but also learn about various nuances of Go to improve our Go coding skills and practices!

Of course, with some humour and life's learnings :P

Transcript

1. © The M.C. Escher Company B.V.
2. Impossible Go! @gautamrege @joshsoftware
3. What to expect from this talk! • Test your Go language skills • Code snippet teasers! • Run actual code with “impossible?” results! • Peek under the language hood to improve your Language concepts and programming practices to become a better programmer! • Earn some goodies when questions are thrown open to you! • Confessions of an Entrepreneur!
4. Where Programming is an Art!
5. Content Sources • Mistakes and goof-ups, unexpected code behaviour • WTF moments. • Anuj Verma - co-author of this talk GoLang Doc specifications are precise “there always a deeper meaning”
6. Let the games begin!
7. Slice Array Wars arr := [8]int{1, 2, 3, 4, 5, 6, 7, 8} s := arr[3:6]
8. Slice Array Wars Slice : [ 4, 5, 6 ] Array: [ 1, 2, 3, 4, 5, 6, 7, 8 ] arr := [8]int{1, 2, 3, 4, 5, 6, 7, 8} s := arr[3:6]
9. Slice Array Wars Slice : [ 4, 5, 6 ] Array: [ 1, 2, 3, 4, 5, 6, 7, 8 ] arr := [8]int{1, 2, 3, 4, 5, 6, 7, 8} s := arr[3:6] s[2] = 10
10. Slice Array Wars Slice : [ 4, 5, 10 ] Array: [ 1, 2, 3, 4, 5, 10, 7, 8 ] arr := [8]int{1, 2, 3, 4, 5, 6, 7, 8} s := arr[3:6] s[2] = 10
11. Slice : [ 4, 5, 10 ] Array: [ 1, 2, 3, 4, 5, 10, 7, 8 ] Slice Array Wars arr := [8]int{1, 2, 3, 4, 5, 6, 7, 8} s := arr[3:6] s[2] = 10 s = append(s, 11)
12. Slice Array Wars Slice : [ 4, 5, 10, 11 ] Array: [ 1, 2, 3, 4, 5, 10, 11, 8 ] arr := [8]int{1, 2, 3, 4, 5, 6, 7, 8} s := arr[3:6] s[2] = 10 s = append(s, 11)
13. Slice Array Wars arr := [8]int{1, 2, 3, 4, 5, 6, 7, 8} s := arr[3:6] s[2] = 10 s = append(s, 11) s = append(s, []int{12, 13, 14}…) Slice : [ 4, 5, 10, 11 ] Array: [ 1, 2, 3, 4, 5, 10, 11, 8 ]
14. Slice Array Wars arr := [8]int{1, 2, 3, 4, 5, 6, 7, 8} s := arr[3:6] s[2] = 10 s = append(s, 11) s = append(s, []int{12, 13, 14}...) Slice : [ 4, 5, 10, 11, 12, 13, 14 ] Array: [ 1, 2, 3, 4, 5, 10, 11, 8 ]
16. Slice Array Wars 8 8 ptr 1 2 3 4 5 6 7 8 Array Len Cap 3 5 ptr Slice Len Cap 0 1 2 3 4 s := arr[3:6]
17. Slice Array Wars 8 8 ptr 1 2 3 4 5 10 7 8 Array Len Cap 3 5 ptr Slice Len Cap s[2] = 10 0 1 2 3 4
18. Slice Array Wars 8 8 ptr 1 2 3 4 5 10 11 8 Array Len Cap 4 5 ptr Slice Len Cap s = append(s, 11) 0 1 2 3 4
19. Slice Array Wars 8 8 ptr 1 2 3 4 5 10 11 8 Array Len Cap 7 10 ptr Slice Len Cap s = append(s, []int{12, 13, 14}...) 4 5 10 11 12 13 14
20. David & Goliath 2 Programmers 2007 1 https://flic.kr/p/5jvooN
21. David & Goliath 2 Programmers Accounting Management Sales Marketing Funds Domain Expertise Contacts 2007 1 https://flic.kr/p/5jvooN
22. David & Goliath 2 Programmers Accounting Management Sales Marketing Funds Domain Expertise Contacts 2007 1 https://flic.kr/p/5jvooN
23. David & Goliath 2 Programmers Accounting Management Sales Marketing Funds Domain Expertise Contacts 2007 1 https://flic.kr/p/5jvooN
24. David & Goliath 2 Programmers Accounting Management Sales Marketing Funds Domain Expertise Contacts 2007 1 https://flic.kr/p/5jvooN
25. David & Goliath 2 Programmers Accounting Management Sales Marketing Funds Domain Expertise Contacts Passion 2007 1 https://flic.kr/p/5jvooN
26. PASSION 106 Programmers 85+ Clients 2019 https://flic.kr/p/8ygVGa
27. Comparisons type MyInt int var a int = 12 b := MyInt(12) fmt.Println(a == b)
28. Comparisons type MyInt int var a int = 12 b := MyInt(12) fmt.Println(a == b) invalid operation: a == b (mismatched types int and MyInt)
29. Comparisons type Foo struct { Name string Age int nickName string realAge int } fakeFoo := struct { Name string Age int nickName string realAge int }{"Gautam", 18, "Boss", 40} realFoo := Foo{"Gautam", 18, "Boss", 40} fmt.Println(fakeFoo == realFoo)
30. Comparisons type Foo struct { Name string Age int nickName string realAge int } fakeFoo := struct { Name string Age int nickName string realAge int }{"Gautam", 18, "Boss", 40} realFoo := Foo{"Gautam", 18, "Boss", 40} fmt.Println(fakeFoo == realFoo) true
31. Comparisons type Foo struct { Name string Age int nickName string realAge int } fakeFoo := struct { Name string Age int nickName string realAge int }{"Gautam", 18, "Boss", 40} realFoo := Foo{"Gautam", 18, "Boss", 40} compareStruct(fakeFoo, realFoo) func compareStruct(a, b interface{}) { fmt.Println(a == b) }
32. Comparisons type Foo struct { Name string Age int nickName string realAge int } fakeFoo := struct { Name string Age int nickName string realAge int }{"Gautam", 18, "Boss", 40} realFoo := Foo{"Gautam", 18, "Boss", 40} compareStruct(fakeFoo, realFoo) func compareStruct(a, b interface{}) { fmt.Println(a == b) }
33. Comparisons type Foo struct { Name string Age int nickName string realAge int } fakeFoo := struct { Name string Age int nickName string realAge int }{"Gautam", 18, "Boss", 40} realFoo := Foo{"Gautam", 18, "Boss", 40} compareStruct(fakeFoo, realFoo) func compareStruct(a, b interface{}) { fmt.Println(a == b) } false
34. Comparisons type Foo struct { Name string Age int nickName string // what's the magic here ??? realAge int } foo := Foo{"Gautam", 18, “Boss", "phew", 40} phoo := Foo{"Gautam", 18, "Boss","tchoo", 40} fmt.Println(foo == phoo) true
35. Comparisons type Foo struct { Name string Age int nickName string _ string realAge int } foo := Foo{"Gautam", 18, “Boss", "phew", 40} phoo := Foo{"Gautam", 18, "Boss","tchoo", 40} fmt.Println(foo == phoo) true
36. Comparisons a1 := [3]int{1, 2, 3} a2 := [3]int{1, 2, 3} fmt.Println(a1 == a2)
37. Comparisons a1 := [3]int{1, 2, 3} a2 := [3]int{1, 2, 3} fmt.Println(a1 == a2) true
38. Comparisons s1 := []int{1, 2, 3} s2 := []int{1, 2, 3} fmt.Println(s1 == s2)
39. Comparisons s1 := []int{1, 2, 3} s2 := []int{1, 2, 3} fmt.Println(s1 == s2) invalid operation: s1 == s2 (slice can only be compared to nil)
40. Comparison Rules • Rule #1: Types are same (except for struct where fields are compared) AND • Rule #2: Values are identical (non-blank fields in struct are ignored) Maps, slices and functions are pointers: No de-referencing Only Interface{} will check dynamic type
41. Camparing Life’s Failures 2
42. Camparing Life’s Failures 2
43. Camparing Life’s Failures 2
44. Camparing Life’s Failures 2
45. Responsibilty ABILITY to RESPOND
46. Iterating Maps func main() { tickets := map[int]string{ 101: "Gautam", 102: "John", 103: "Jane", 104: "Doe", 105: "Jeremy", 106: "Adam", 107: "Jack", 108: "Zoe", 201: "Regies", 202: "Anuj", 203: "Jake", 204: "Ivy", 205: "Anusha", 206: "Adam", 207: "Will", 208: "Eva", } for k, v := range tickets { fmt.Println(k, v) } }
47. Impossible? p1, err := NewPerson(name, age) if err != nil { fmt.Println("Person not born!") } p4, err := NewPerson(name, age, weight, height) if err != nil { fmt.Println("Person not born!") }
48. Impossible? p1, err := NewPerson(name, age) if err != nil { fmt.Println("Person not born!") } p4, err := NewPerson(name, age, weight, height) if err != nil { fmt.Println("Person not born!") }
49. Functional Options type option func(*Server) func tls(val bool) option { return func(s *Server) { s.Tls = val } } func timeout(ts int) option { return func(s *Server) { s.Timeout = ts } } func NewServer(opts …option) (Server, error) { // defaults p := Server{false, 600, 5} for _, f := range opts { f(&p) } return p, nil } s1, e := NewServer(tls(true), timeout(9600)) s2, e := NewServer()
50. • 29 different API integrations from Insurance companies • Interface’d but require different configurations - SOAP, JSON, direct SAP API, custom protocol • Dave Chaney (https://dave.cheney.net/2014/10/17/functional-options- for-friendly-apis) • Rob Pike (https://commandcenter.blogspot.com/2014/01/self- referential-functions-and-design.html) • Why not just support default parameters?
51. • 29 different API integrations from Insurance companies • Interface’d but require different configurations - SOAP, JSON, direct SAP API, custom protocol • Dave Chaney (https://dave.cheney.net/2014/10/17/functional-options- for-friendly-apis) • Rob Pike (https://commandcenter.blogspot.com/2014/01/self- referential-functions-and-design.html) • Why not just support default parameters? #chavedeney
52. Possible? type IronMan struct { Fly bool SuperSpeed bool Immortal bool } type Powers interface { Identity() } type SuperHero struct { Powers } ironman := `{ "Powers": { "Fly": true, "SuperSpeed": false, "Immortal": false } }` var sh SuperHero json.Unmarshal([]byte(ironman), &sh) sh.Identity()
53. Possible? type IronMan struct { Fly bool SuperSpeed bool Immortal bool } type Powers interface { Identity() } type SuperHero struct { Powers } ironman := `{ "Powers": { "Fly": true, "SuperSpeed": false, "Immortal": false } }` var sh SuperHero json.Unmarshal([]byte(ironman), &sh) sh.Identity() json: cannot unmarshal object into Go struct field SuperHero.Powers of type main.Powers
54. func (sh *SuperHero) UnmarshalJSON(b []byte) error { var s struct { Powers map[string]bool } s.Powers = make(map[string]bool) _ = json.Unmarshal(b, &s) if s.Powers["Fly"] && s.Powers["SuperSpeed"] { sh.Powers = IronMan{} } else if s.Powers["Immortal"] && s.Powers["SuperStrength"] { sh.Powers = Thanos{} } else { sh.Powers = WTFHero{} } return nil } UnmarshalJSON
55. func (sh *SuperHero) UnmarshalJSON(b []byte) error { var s struct { Powers map[string]bool } s.Powers = make(map[string]bool) _ = json.Unmarshal(b, &s) if s.Powers["Fly"] && s.Powers["SuperSpeed"] { sh.Powers = IronMan{} } else if s.Powers["Immortal"] && s.Powers["SuperStrength"] { sh.Powers = Thanos{} } else { sh.Powers = WTFHero{} } return nil } UnmarshalJSON
56. Zero Trust Access •Making the VPN obsolete. •Continuous authorization for Hybrid and Multi Cloud •Integration with different MDMs •Integration with different IDPs Federated OpenID Connect provider
57. Dex Storage Connectors // ConnectorConfig is a configuration that can open a connector. type ConnectorConfig interface { Open(id string, logger logrus.FieldLogger) (connector.Connector, error) } // ConnectorsConfig variable provides an easy way to return a config struct // depending on the connector type. var ConnectorsConfig = map[string]func() ConnectorConfig{ "github": func() ConnectorConfig { return new(github.Config) }, "oidc": func() ConnectorConfig { return new(oidc.Config) }, "saml": func() ConnectorConfig { return new(saml.Config) }, "microsoft": func() ConnectorConfig { return new(microsoft.Config) }, }
58. To exit or not to exit func main() { var result int for i := 0; i < 8; i++ { go func() { for { result++ } }() } // spawn the go-routines time.Sleep(time.Second) fmt.Println("exiting...") } main() is non-blocking No WaitGroups
59. To exit or not to exit func main() { var result int for i := 0; i < 8; i++ { go func() { for { result++ } }() } // spawn the go-routines time.Sleep(time.Second) fmt.Println("exiting...") } main() is non-blocking No WaitGroups
60. Go Routines Context Switch File IO Sleep Channel Wait
61. Zephyr • Next Generation Vinyl Record Player • Raspberry Pi & Arduino • 2 motors and 4 limit sensors monitored using go-routines. • Continuous Computing for platter motor next position to maintain 33.5 or 45 rpm
62. Don't forget to live! 3
63. Don't forget to live! 3
64. Don't forget to live! 3
65. Don't forget to live! 3
66. Don't forget to live! 3
67. Don't forget to live! 3
68. Don't forget to live! 3
69. Don't forget to live! 3
70. Don't forget to live! 3
71. 4 #RetireBy40 Financial freedom No daily office routine Work because you want to, not because you need to! Do things you love to do!
72. up yours
73. Disrupt your Industry @gautamrege @joshsoftware