Introduction to Go

Presented in Portuguese (Brazil) here: https://www.youtube.com/watch?v=VKOxJVS-mvA&feature=youtu.be

Transcript

1. Gabriel Sobrinho . Codeminer42 . May 2020 https://github.com/sobrinho https://twitter.com/sobrinho Introduction to Go
2. Introduction • Blazing fast • Compiled • Strongly statically typed (with inference) • No exception handling • Concurrency using lightweight threads
3. package main import "fmt" func main() { fmt.Println("Hello, world!") }
4. $ go run hello.go Hello, world!
5. No exceptions!
6. Exceptions • Use multiple return values to emulate try/catch • Use defer to emulate try/catch/finally • Defer stacks functions to be called when the closest function execution is done
7. try/catch
8. func main() { data, err := ioutil.ReadFile("/tmp/file") if err != nil { fmt.Println(err.Error()) return } fmt.Println(data) }
9. $ go run read.go open /tmp/file: no such file or directory
10. $ echo "my content" > /tmp/file $ go run read.go my content
11. try/catch/finally
12. func main() { defer fn(1) fmt.Println("Hello, world!") } func fn(x int) { fmt.Println(x) }
13. $ go run defer.go Hello, world! 1
14. func main() { defer fn(1) defer fn(2) fmt.Println("Hello, world!") defer fn(3) } func fn(x int) { fmt.Println(x) }
15. $ go run defer.go Hello, world! 3 2 1
16. finally the finally
17. func main() { var file, err = os.OpenFile("/tmp/file", os.O_RDWR, 0644) if err != nil { fmt.Println(err.Error()) return } defer file.Close() var len, err = file.Write([]byte("my content")) if err != nil { fmt.Println(err.Error()) } }
18. coroutines
19. Coroutines • Lightweight threads • Used for async processing • Any function can be called in a coroutine • Communication using channels • You can wait for the result using select
20. timeout
21. func main() { tc := make(chan bool) rc := make(chan string) go timeout(tc) go read(rc) select { case word := <-rc: fmt.Println("Received", word) case <-rc: fmt.Println("Timeout.") } }
22. func read(ch chan string) { fmt.Println("Type a word, then hit Enter.") var word string fmt.Scanf("%s", &word) ch <- word } func timeout(ch chan bool) { time.Sleep(5 * time.Second) ch <- true }
23. func main() { tc := make(chan bool) rc := make(chan string) go timeout(tc) go read(rc) select { case word := <-rc: fmt.Println("Received", word) case <-tc: fmt.Println("Timeout.") } }
24. $ go run concurrency.go Type a word, then hit Enter. Timeout. $ go run concurrency.go Type a word, then hit Enter. hello<CR> Received hello
25. You can grossly compare Go's select{} with JavaScript's Promise.race()
26. There is also sync.WaitGroup if you need to wait for a specific number of coroutines to finish Another grossly comparison to JavaScript's Promise.all()
27. What have you done so far with Go? • A service that invokes a text-speech engine in macOS • A service that profile and search fingerprints using a DLL in Windows • A service that exposes local files in both platforms for reading/writing • All exposed through REST APIs in localhost
28. See the pattern? You can easily expose local assets, software and hardware, to web applications!
29. But that's not all...
30. What the community have done so far with Go? • docker - a set of tools for deploying Linux containers • kubernetes - container management system • openshift - RedHat's PaaS • terraforma - infrastructure provisioning tool • caddy - open source HTTP/2 web server with HTTPS capability • mattermost - a teamchat system
31. Who is notable using it? • Cloudflare • Dropbox • Google • Netflix • SoundCloud • Uber • And more...
32. What are you capable of doing with Go?
33. Thanks!