Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Go advice

Go advice

Oleg Kovalov

October 25, 2018
Tweet

More Decks by Oleg Kovalov

Other Decks in Programming

Transcript

  1. GO ADVICES KRAKOW POLAND, OCT 25 2018 Oleg Kovalov Allegro

    Twitter: oleg_kovalov Github: cristaloleg
  2. Me

  3. Use raw strings func main() { value := "ʕ◔ϖ◔ʔ" a

    := "{\"key\":\"" + value + "\"}" b := "{" + "\"key\":\"" + value + "\"" + "}" c := `{"key":"` + value + `"}` println(a == c && b == c) println(c) } // true // {"key":"ʕ◔ϖ◔ʔ"} Strings should be human readable
  4. Use raw strings for regex func main() { value :=

    "ʕ◔ϖ◔ʔ" a := "\"\\<h3\\>.*\\</h3\\>\"" b := `"\<h3\>.*\</h3\>"` println(a) println(b) } // "\<h3\>.*\</h3\>" // "\<h3\>.*\</h3\>" REgexp means readable
  5. type helloRequest struct { Name string `json:"name"` Toke string `json:"token"`

    } type helloResponse struct { Message string `json:"message"` } func helloHandler(...) { // process helloRequest/helloResponse } type confirmRequest struct { ... } type confirmResponse struct { ... } func confirmHandler(...) { ... } Just a HTTP handler The obvious way to declare req/resp :(
  6. Function scope types func helloHandler(...) { type request struct {

    Name string `json:"name"` Toke string `json:"token"` } type response struct { Message string `json:"message"` } var req request var resp response // process request/response } But we can do better :)
  7. Anonymous types func helloHandler(...) { type request struct { Name

    string `json:"name"` Toke string `json:"token"` } // process request var response = struct { Message string `json:"message"` }{ Message: “yo, GoGoConf”, } // process request } or with an anonymous type :D
  8. Because someone said defer is slow var mu sync.Mutex func

    foo() interface{} { mu.Lock() if !flag { mu.Unlock() return nil } // do some stuff // oops… return value } Suddenly we have a locked mutex
  9. Let’s do not omit a defer var mu sync.Mutex func

    foo() interface{} { mu.Lock() defer mu.Unlock() if !flag { return nil } // do some stuff // huh… everything is fine return value } And suddenly we have… no problems
  10. What is the problem? var i int64 var mu sync.RWMutex

    http.HandleFunc("/add", func(...) { mu.Lock() defer mu.Unlock() i++ fmt.Fprintf(w, "count: %d\r\n", i) }) http.HandleFunc("/status", func(...) { mu.RLock() defer mu.RUnlock() fmt.Fprintf(w, "count: %d\r\n", i) }) It’s race free. I promise.
  11. Slow client will kill our app var i int64 var

    mu sync.RWMutex http.HandleFunc("/add", func(...) { mu.Lock() defer mu.Unlock() i++ fmt.Fprintf(w, "count: %d\r\n", i) }) http.HandleFunc("/status", func(...) { mu.RLock() defer mu.RUnlock() fmt.Fprintf(w, "count: %d\r\n", i) }) Over protected
  12. IO operation should be cancelable or timeoutable Have a timeout

    for IO operations. srv := &http.Server{ Addr: ":8080", Handler: router, ReadTimeout: 3 * time.Second, WriteTimeout: 5 * time.Second, MaxHeaderBytes: 1 << 20, } srv.ListenAndServe()
  13. // don’t var netClient = &http.DefaultClient{} // do var netClient

    = &http.Client{ Timeout: 10 * time.Second, } // or even more pedantic var netTransport = &http.Transport{ Dial: (&net.Dialer{ Timeout: 3 * time.Second, }).Dial, TLSHandshakeTimeout: 3 * time.Second, } netClient.Transport = netTransport IO operation should be cancelable or timeoutable Omit http DefaultClient
  14. func out() chan int { ch := make(chan int) go

    func() { var i int64 for { ch <- i i++ } }() return ch } func foo() { ch := out() for c := range ch { ... } } Simple code, huh How to shoot yourself into the foot
  15. func out() chan int { ch := make(chan int) go

    func() { var i int64 for { ch <- i // *BANG* i++ } }() return ch } func foo() { ch := out() // read from ch a bit and... close(ch) // and make a panic, probably } Don't close in-channel *BANG*
  16. func out() <-chan int { ch := make(chan int) go

    func() { var i int64 for { ch <- i // just send, right? i++ } }() return ch } func foo() { ch := out() // read from ch a bit and... close(ch) // hah, compilation error // invalid operation: close(ch) // (cannot close receive-only channel) } Specify a channel direction One small arrow for developer One giant leap for safety
  17. import "sync" func main() { var greetOnce sync.Once for i

    := range [10]struct{}{} { println(i) greetOnce.Do(func() { print("hey, there!") }) } } // 0hey, there!123456789 Not so common for-loop Don’t use it :)
  18. import "sync" func main() { var greetOnce sync.Once for i

    := range [10]struct{}{} { println(i) greetOnce.Do(func() { print("hey, there!") }) } } // 0hey, there!123456789 Do something once with sync.Once No comments
  19. package cache var keyValue map[string][]byte func Get(k string) ([]byte, bool)

    { return keyValue[k] } func Set(k string, v []byte) { keyValue[k] = v } package service func foo() { cache.Set(“conf”, “GoGoConf”) } Avoid a global state Yeah, it works
  20. package cache var CacheType string var keyValue map[string][]byte var redisClient

    *redis.Client func Get(k string) ([]byte, bool) { switch CacheType { case “inmemory”: return keyValue[k] case “redis”: return redisClient.Get(k) ... } } But how to make it different? Oh..that’s hard
  21. package inmemory type Cache struct { data map[string][]byte } func

    New() *Cache {...} func (c*Cache) Get(k string) ([]byte, bool) {...} func (c*Cache) Set(k string, value []byte) {...} package service func foo() { c := inmemory.New() c.Set(“best conf”, “GoGoConf”) } Let’s make it simpler And it’s Easy to test
  22. package cache type Cache interface { Get(k string) (value []byte,

    ok bool) Set(k string, value []byte) } package inmemory type Cache struct { data map[string][]byte } func (c*Cache) Get(k string) ([]byte, bool) {...} func (c*Cache) Set(k string, value []byte) {...} package redis // ... Let’s make it changable Agile™
  23. body := `{ “id”: “i-am-so-random-woah”, “timestamp”: 123456789, “data”: { “sub_params”:

    { “oh_please_stop”: [{ ... }] }, “tet_another”: {...}, } }` var m map[string]interface{} json.Unmarshal([]byte(body), &m) // slow :( // and we need only id & timestamp Unmarshal JSON JSON from a production
  24. Lazy Unmarshalling type Body struct { ID string `json:”id”` Timestamp

    int `json:”timestamp”` Data json.RawMessage `json:”data”` } // encoding/json.go // type RawMessage []byte var m Body json.Unmarshal([]byte(body), &m) // fast :) timestamp := m.Timestamp We can make it type-safe
  25. Table-driven tests func TestSomething(t *testing.T) { testCases := []struct{ name

    string a,b int64 res int64 }{ {“simple case”, 1, 2, 3}, {“less simple”, 3, 3, 23}, {“omg”, 42, 78, 30307}, } for _, tc := range testCases { t.Logf(“test: %s”, tc.name) res := foo(tc.a, tc.b) if res != tc.res { t.Errorf(“want %v, got %v, res, tc.res) } } Table & test
  26. Order independent test func TestSomething(t *testing.T) { testCases := map[name]struct{

    a,b int64 res int64 }{ “simple case”: {1, 2, 3}, “less simple”: {3, 3, 23}, “omg”: {42, 78, 30307}, } for name, tc := range testCases { t.Logf(“test: %s”, name) res := foo(tc.a, tc.b) if res != tc.res { t.Errorf(“want %v, got %v, res, tc.res) } } } Hardening
  27. Use build tags in tests And we need to edit

    every test like that package service_test var iTests = flag.Bool("integration", false, "<docs>") func TestSomething(t *testing.T) { if !*iTests { t.Skip(“skipping test because of”) } if service.IsMeaningful() != 42 { t.Errorf(“oh no!”) } } // And run: go test ./... -args integration
  28. Use build tags in tests // +build integration package service_test

    func TestSomething(t *testing.T) { if service.IsMeaningful() != 42 { t.Errorf(“oh no!”) } } // And run: go test --tags integration ./... Voilà! ®