1. Golang 101
Eric Fu
May 15, 2017 @ Splunk

2. Hello, World
package main
import "fmt"
func main() {
fmt.Println("hello world")
}
2

3. Hello, World
again
package main
import "fmt"
func main() {
ch := sayHello("World")
for str := range ch {
fmt.Println(str)
}
}
func sayHello(name string) <-chan string
{
ch := make(chan string)
go func() {
defer close(ch)
ch <- "Hello"
ch <- name
}()
return ch;
}
3

4. What is Go?
Go is an open source programming language that makes it easy to build
simple, reliable, and efficient software.
- golang.org
4

5. History
• Open source since 2009 with a very active community.
• Language stable as of Go 1, early 2012
• Latest Version: Go 1.8, released on Feb 2017
5

6. Designers
V8 JavaScript engine, Java HotSpot VM
Robert Griesemer Rob Pike
UNIX, Plan 9, UTF-8
Ken Thompson
UNIX, Plan 9, B language, UTF-8
6

7. Why Go?
• Go is an answer to problems
of scale at Google
7

8. System Scale
• Designed to scale to 10⁶⁺ machines
• Everyday jobs run on 1000s of machines
• Jobs coordinate, interacting with others in the system
• Lots going on at once
Solution: great support for concurrency
8

9. Engineering Scale
• 5000+ developers across 40+ offices
• 20+ changes per minute
• 50% of code base changes every month
• 50 million test cases executed per day
• Single code tree
Solution: design the language for large code bases
9

10. Who uses Go?
10

11. Assuming you know Java...
• Statically typed
• Garbage collected
• Memory safe (nil references, runtime bounds checks)
• Methods
• Interfaces
• Type assertions (instanceof)
• Reflection
11

12. Leaved out...
• No classes
• No constructors
• No inheritance
• No final
• No exceptions
• No annotations
• No user-defined generics
12

13. Add some Cool things
• Programs compile to machine code. There's no VM.
• Statically linked binaries
• Control over memory layout
• Function values and lexical closures
• Built-in strings (UTF-8)
• Built-in generic maps and arrays/slices
• Built-in concurrency
13

14. Built-in Concurrency
CSP - Communicating sequential processes (Hoare, 1978)
• Sequential execution is easy to understand. Async callbacks are not.
• “Don't communicate by sharing memory, share memory by
communicating.”
CSP in Golang: goroutines, channels, select
14

15. Goroutines
• Goroutines are like lightweight threads.
• They start with tiny stacks and resize as needed.
• Go programs can have hundreds of thousands of them.
• Start a goroutine using the go statement: go f(args)
• The Go runtime schedules goroutines onto OS threads.
15

16. Channels
• Provide communication between goroutines.
c := make(chan string)
// goroutine 1
c <- "hello!"
// goroutine 2
s := <-c
fmt.Println(s) // "hello!"
16

17. Buffered vs. Unbuffered Channels
coroutine producer/consumer
17
c := make(chan string) c := make(chan string, 42)

18. Hello, World
again
package main
import "fmt"
func main() {
ch := sayHello("World")
for str := range ch {
fmt.Println(str)
}
}
func sayHello(name string) <-chan string {
ch := make(chan string)
go func() {
defer close(ch)
ch <- "Hello"
ch <- name
}()
return ch;
}
18

19. Select
• A select statement blocks until communication can proceed.
select {
case n := <-foo:
fmt.Println("received from foo", n)
case n := <-bar:
fmt.Println("received from bar", n)
case <- time.After(10 * time.Second)
fmt.Println("time out")
}
19

20. Function & Closure
• Local variable escape
20
#include <string>
#include <iostream>
#include <functional>
using namespace std;
function<void()> numberPrinter(int x) {
return [&]() {
cout << "Printer: " << x << endl;
};
}
int main()
{
numberPrinter(123)();
}

21. Hello, World
again
package main
import "fmt"
func main() {
var ch = sayHello("World")
for str := range ch {
fmt.Println(str)
}
}
func sayHello(name string) <-chan string {
ch := make(chan string)
go func() {
defer close(ch)
ch <- "Hello"
ch <- name
}()
return ch;
}
21

22. Struct
• Control over memory layout
• Value vs. pointer (reference)
type Example struct {
Number int
Data [128]byte
Payload struct{
Length int
Checksum int
}
}
22
func (e *Example) String() string {
if e == nil {
return "N/A"
}
return fmt.Sprintf("Example %d", e.Number)
}

23. Method & Interface
• Simple interfaces
• Duck type
23
// In package "fmt"
type Stringer interface {
String() string
}

24. Interface and Type assertion
• Empty interface{} means any type
24
func do(i interface{}) {
switch v := i.(type) {
case int:
fmt.Printf("Twice %v is %vn", v, v*2)
case string:
fmt.Printf("%q is %v bytes longn", v, len(v))
default:
fmt.Printf("I don't know about type %T!n", v)
}
}

25. Compiled to binary
• Run fast
• Compile fast
• Deploy fast
https://benchmarksgame.alioth.debian.org/u64q/fasta.html25

26. Talk is cheap
Show me the code!
26

27. Design a Microservice
27

28. Design Secure Store for LSDC
28

29. Design Secure Store for LSDC
• Listen on API calls from other micro-services
• While got a request...
• Run a handler function in a new Goroutine to handle this request
• Pass a channel (context) to control request timeout
• Back to main loop, waiting for next request
• The hander function does:
• For PUT: encrypt the secret with KMS, put it into DynamoDB
• For GET: query it from DynamoDB, decrypt secret with KMS
29

30. Storage Service Interface
package storage
import (
"context"
"splunk.com/lsdc_secure_store/common"
)
type Service interface {
PutSecret(ctx context.Context, secret *SecretRecord) error
GetSecret(ctx context.Context, id string) (*SecretRecord, error)
}
type SecretRecord struct {
common.SecretMetadata
common.SecretTriple
}
30

31. Key Service Interface
package keysrv
type Service interface {
GenerateKey(context *SecretContext, size int) (*GeneratedKey, error)
DecryptKey(context *SecretContext, ciphertext []byte) ([]byte, error)
}
type GeneratedKey struct {
Plaintext []byte
Ciphertext []byte
}
type SecretContext struct {
Realm string
Tenant string
}
31

32. GetSecret
32
func GetSecret(ctx context.Context, id, tenant, realm string) (*common.Secret, error) {
record, err := storageService.GetSecret(ctx, id)
if err != nil {
return nil, err
}
if err := verifyTenantRealm(ctx, record, realm, tenant); err != nil {
return nil, err
}
plaintext, err := Decrypt(ctx, keyService, &keysrv.SecretContext{realm, tenant},
&record.SecretTriple)
if err != nil {
return nil, err
}
return &common.Secret{
SecretMetadata: record.SecretMetadata,
Content: string(plaintext),
}, nil
}

33. context.Context
• control request timeout
• other request context
33
func Stream(ctx context.Context, out chan<-
Value) error {
for {
v, err := DoSomething(ctx)
if err != nil {
return err
}
select {
case <-ctx.Done():
return ctx.Err()
case out <- v:
}
}
}
type Context interface {
Deadline() (deadline time.Time, ok bool)
Done() <-chan struct{}
Err() error
Value(key interface{}) interface{}
}

34. Set handler
func GetRealmsRealmSecretsID(params secret.GetSecretParams) middleware.Responder {
sec, err := secstore.GetSecret(...)
if err != nil {
return handleError(err)
} else {
return secret.NewGetSecretOK().WithPayload(&models.SecretDataResponse{
Data: &models.SecretData{
Alias: &sec.Alias,
Data: &sec.Content,
LastModified: &sec.LastUpdate,
},
})
}
}
api.SecretGetSecretHandler =
secret.GetSecretHandlerFunc(handlers.GetRealmsRealmSecretsID)
34

35. Demo (optional)
35
• A very basic http server
cd $GOPATH/src/github.com/fuyufjh/gowiki
vim server.go
gofmt -w server.go
go get
go run server.go
go build -o server server.go

36. So, What is ‘Gopher’?
36

37. Summary
• concurrent
• fast
• simple
• designed for large scale software
37

38. Thanks!
38
Learn Go > https://tour.golang.org