Effective Go

Question 1

How do you verify the expected output from Go Example code?

Answer 1

Use an output comment after the print code. e.g.

func ExampleURL() {
    u, err := url.Parse("http://foo.com/go")
    if err != nil {
        log.Fatal(err)
    }
    u.Scheme = "https"
    fmt.Println(u)
    // Output:
    // http://foo.com/go
}

Question 2

How is unordered expected output handled in Example code?

Answer 2

Where the output is in a random order you can use the following comment:

func ExamplePerm() {
    r := rand.New(rand.NewSource(time.Now().UnixNano()))
    for _, v := range r.Perm(3) {
        fmt.Println(v)
    }
    // Unordered output:
    // 2
    // 0
    // 1
}

Question 3

Give the commands that generate a coverage profile and then view it in your default browser

Answer 3

go test -coverprofile cover.out
go tool cover -html=cover.out

Question 4

How can you toggle a view of unit test coverage with the vim-go plugin

Answer 4

:GoCoverageToggle
<leader>c

Question 5

Generate a coverage profile and save it to a file named cover.out

Answer 5

go test -coverageprofile cover.out

Question 6

View the coverage profile from a the file cover.out in a browser

Answer 6

go tool cover -html=cover.out

Question 7

Show the test coverage in percentage without needing a coverage profile file

Answer 7

go test -cover

Question 8

Give the command to run benchmarks

Answer 8

go test -bench .

Question 9

What method can you call to report allocations in a benchmark

Answer 9

b.ReportAllocs()

Question 10

What commands can be used to comparing benchmark results

Answer 10

$ go install golang.org/x/perf/cmd/benchstat@latest
go test -bench . -count 10 > old.txt
...optimise code...
go test -bench . -count 10 > new.txt
benchstat old.txt new.txt

Question 11

What command runs a benchmark test 10 times

Answer 11

go test -bench . -count 10

Question 12

Give an example of an import statement

Answer 12

import "fmt"

Question 13

Give and example of a factored import statement

Answer 13

import (
“fmt”
“math”
)

Question 14

What are exported names

Answer 14

In Go, a name is exported if it begins with a capital letter.

When importing a package, you can refer only to its exported names.

Question 15

Declare a function to add two values x and y

Answer 15

func add(x, y int) int {
    return x + y
}

Question 16

What is a naked return value

Answer 16

A return statement without arguments returns the named return values.

Naked returns should only be used in short functions.

Question 17

What is a var statement

Answer 17

The var statement declares a list of variables. The type is last. e.g.

var x, y, z int

Question 18

What is an initialiser

Answer 18

When declaring a variable you can also set it’s initial value. e.g.

var i int = 1

If an initialiser is present, the type can be omitted. e.g.

var i = 1

Question 19

What is a short variable declaration

Answer 19

Inside a function, the := short assignment statement can be used in place of a var declaration with implicit type. e.g.

i := 1
c := true
c, python, java := true, false, "no!"

Question 20

What are Go’s basic types

Answer 20

~~~
bool

string

int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr

byte // alias for uint8

rune // alias for int32; represents a Unicode code point

float32 float64

complex64 complex128

Question 21

What does the format verb %q output

Answer 21

Prints a double-quoted string safely escaped with Go syntax

Question 22

What does the format verb %v print

Answer 22

The value in a default format.

Question 23

What does the format verb %+v print

Answer 23

Where the value is a struct, the plus flag adds field names.

Question 24

What does the format verb %#v print

Answer 24

a Go-syntax representation of the value

Question 25

What does the format verb %T print

Answer 25

a Go-syntax representation of the type of the value

Question 26

What does the format verb %t print

Answer 26

the work `true` or `false`

Question 27

What third-party package is useful for comparing complex types

Answer 27

`go-cmp`

Question 28

What is a _raw string literal_

Answer 28

This is a string delimited by backticks. The Go compiler does not interpret what is in a raw string.

Question 29

Give the command to print the Go Operating System and Go Architecture

Answer 29

``` go env GOOS GOARCH ```

Question 30

Give the command to print a list of all operating systems that yo can compile

Answer 30

``` go tool dist list -json ```

Question 31

Build for the Linux OS on the AMD64 architecture

Answer 31

``` GOOS=linux GOARCH=amd64 go build ```

Question 32

What is a _closure_

Answer 32

A closure is a function value that references variables from outside its body.

Question 33

What is a variadic func

Answer 33

A variadic func accepts variable number of input values - zero or more. Ellipsis (three-dots) prefix in front of an input type makes a func variadic. ``` func f(names ... string) ```

Question 34

Give an example of a simple variadic func

Answer 34

``` func toFullname(names ...string) string { return strings.Join(names, " ") } ```

Question 35

TIP: A simple API is...

Answer 35

A simple API is better than a complicated one. Hide complexity behind a simple API.

Question 36

TIP: Concurrency is an...

Answer 36

Concurrency is an implementation detail. Design a synchronous API and let the users of your package decide when to use concurrency or not. For example, the Go standard library's API is mostly synchronous.

Question 37

TIP: twins

Answer 37

It's a common practice to create twins. `Do` is like an entry point and handles higher-level stuff, while do handles the specifics.

Question 38

TIP: `time.Since` returns...

Answer 38

`time.Since` returns the time duration between time values. It's a shortcut for `time.Now.Sub(t)`

Question 39

What is a concurrent pipeline?

Answer 39

A pipeline is an extensible and efficient design pattern consisting of concurrent stages. Each stage does something and sends a message to the next via channels.

Question 40

Tip: Using directional channels...

Answer 40

Using directional channels (recieve-only and send-only) prevents you from introducing bugs in the future and show the intentions of what to do (and what you cannot and should not do) with a channel.

Question 41

TIP: Only the channel's owner..

Answer 41

Only the channel's owner should close a channel to ensure all values are sent.

Question 42

The _Orchestrator Function_ pattern

Answer 42

Separating a function that contains the main logic from the goroutine that would run it.