Crowdly

Optional configuration parameters for every function

Replacing explicit dependencies in constructors

Request-scoped data that crosses API and process boundaries

A goroutine returns an error

Which description best matches a goroutine leak?

A goroutine modifies a package-level variable

A goroutine executes on more than one OS thread

A goroutine remains blocked or running after its work is no longer needed and has no effective termination path

It blocks indefinitely unless execution is otherwise terminated

What happens when this send operation is reached?

var ch chan int
ch <- 1

The channel is initialized automatically

The value is discarded

It panics immediately

The supplied function is retried until it succeeds

What guarantee does sync.Once provide for calls to its Do method on the same Once value?

The supplied function is executed at most once

Only one goroutine can exist after Do returns

The supplied function is executed once per goroutine

What is printed by the following Go code?

type MyError struct{}
func (*MyError) Error() string { return "error" }
var p *MyError = nil
var err error = p
fmt.Println(err == nil)

Comparing an interface with nil always returns false

Why is err not nil in the following code?

var p *MyError = nil
var err error = p

The error interface creates a non-nil default value automatically

The interface has a dynamic type *MyError even though its dynamic value is a nil pointer

Interface values can never be nil

It is encoded with the key -

What happens to the Password field during JSON marshaling?

type User struct {
    Name     string `json:"name"`
    Password string `json:"-"`
}

It is omitted from the JSON output

Marshaling fails

It is encoded with the key Password

To delete the HTTP request from the server

Why should an HTTP response body obtained from http.Client normally be closed?

To release resources associated with the response and enable connection reuse when possible

To convert the response to JSON

To terminate the Go runtime

When the surrounding function returns

When are the arguments of a deferred function call evaluated?

When the defer statement is evaluated

When the deferred call is executed

Only if a panic occurs

Which expression idiomatically adds context to err while preserving it for errors.Is and errors.As?

fmt.Print(err)

errors.New(err.Error())

fmt.Errorf("operation failed: %w", err)

fmt.Sprintf("operation failed: %v", err)