Go Programming Practice Exam — LearnCoachAssist

Question 1 Go Programming

What is t.Helper used for?

b.RunParallel(func(pb *testing.PB) { for pb.Next() { work() } }) runs the benchmark across GOMAXPROCS goroutines to measure parallel performance. Use -cpu flag to control the parallelism level. w.Write([]byte) writes the response body. If no status has been sent, it implicitly sends 200 OK.
w.WriteHeader(404) sends the status code without a body. Call it before writing the body to set a non-200 status. t.Helper() marks a function as a test helper: failure messages report the caller's line number, not the helper's. Always call it in helpers like assertEqual to make test failures easier to read. Go's runtime uses an M:N scheduler that maps M goroutines onto N OS threads. Components:

G = goroutine
M = OS thread (machine)
P = logical processor holding a run queue

Work stealing between Ps keeps load balanced.

Question 2 Go Programming

What is a map iteration order?

Use the time.Format method with a reference layout "Mon Jan 2 15:04:05 MST 2006" (01/02 03:04:05PM '06):
t.Format("2006-01-02 15:04:05")
For RFC 3339 / ISO 8601 use the constant time.RFC3339. sync.Mutex provides mutual exclusion for shared data:
var mu sync.Mutex
mu.Lock()
// critical section
mu.Unlock()
Use sync.RWMutex for multiple readers with a single writer pattern. Always use defer mu.Unlock() for safety. Map iteration order in Go is intentionally randomized (since Go 1.0). Each for k, v := range m returns keys in a different order. Do not rely on iteration order; sort keys if you need deterministic output. go build -trimpath removes all file system paths from the binary, replacing them with module paths. This makes builds reproducible across machines and avoids leaking local directory structure. Recommended for production builds.

Question 3 Go Programming

How does the context package work?

The context package manages deadlines, cancellation, and request-scoped values:
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
Pass ctx to functions and check ctx.Done() for cancellation. A type switch inspects the concrete type of an interface value:

switch v := i.(type) {
case int:
  fmt.Println("int:", v)
case string:
  fmt.Println("string:", v)
default:
  fmt.Println("unknown")
}

The net/http package provides a built-in web server:

http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
  fmt.Fprintln(w, "Hello!")
})

http.ListenAndServe(":8080", nil)
It also provides an HTTP client: resp, err := http.Get("https://example.com") golang.org/x/sync/semaphore limits concurrency to N using a weighted semaphore:
sem := semaphore.NewWeighted(10)
sem.Acquire(ctx, 1)
Useful when you have many tasks but want to bound parallel resource use (e.g. DB connections, file handles).

Question 4 Go Programming

What is the embed package?

Introduced in Go 1.16, embed lets you embed files into the binary:
import _ "embed"
//go:embed hello.txt
var s string
Files become variables. Useful for shipping templates, configs, and static assets with no runtime file dependency. resp, err := http.Get("https://api.example.com/data")
For POST/PUT etc.:
req, _ := http.NewRequest("POST", url, body)
resp, err := http.DefaultClient.Do(req)
Always defer resp.Body.Close() and read the body to completion. Implement String() string from the fmt package:

func (p Person) String() string {
  return fmt.Sprintf("%s (%d years)", p.Name, p.Age)
}

Now fmt.Println(p) uses your custom format automatically. Nil string: there is no string; the variable is nil (only possible for uninitialized interface/pointer contexts).
Empty string "": a string with length 0 but not nil. The zero value of string is "", not nil — strings are values, not references.

Question 5 Go Programming

How do you write a string with Unicode escapes?

Use a blank variable assignment to force compile-time check:
var _ io.Reader = (*MyType)(nil)
This fails to compile if *MyType does not satisfy io.Reader. A common idiom in package initialization. Go string literals support: \x (2 hex digits), \u (4 hex digits, Unicode), \U (8 hex digits), \nnn (octal).
"\u00e9" → "é"
Raw string literals (backticks) interpret no escapes. Methods are functions with a receiver argument:

func (p Person) Greet() string {
  return "Hi, " + p.Name
}

Use a pointer receiver (p *Person) to modify the struct or avoid copying. []byte("hello") — string to byte slice (allocates and copies).
string(b) — byte slice to string (allocates and copies).
In Go 1.20+, conversion to []byte no longer escapes in some cases, reducing allocations. Use unsafe only with extreme care.

Question 6 Go Programming

How do you make an HTTP request in Go?

encoding/binary reads and writes fixed-size binary values to/from byte slices: binary.BigEndian.PutUint32(buf, v), binary.LittleEndian.Uint16(buf). It also defines binary.Read and binary.Write for struct I/O. resp, err := http.Get("https://api.example.com/data")
For POST/PUT etc.:
req, _ := http.NewRequest("POST", url, body)
resp, err := http.DefaultClient.Do(req)
Always defer resp.Body.Close() and read the body to completion. testing.TB is the shared interface of *testing.T and *testing.B — exposes Log, Logf, Error, Fatal, Skip, Helper, Cleanup. Useful when writing helpers that work in both tests and benchmarks. Two operations have a happens-before relationship if Go's memory model guarantees the second sees the first's effects. Channel sends happen before the corresponding receive completes; Unlock happens before the next Lock. Without such a relationship, behavior is undefined.

Question 7 Go Programming

What is a happens-before relationship?

Two operations have a happens-before relationship if Go's memory model guarantees the second sees the first's effects. Channel sends happen before the corresponding receive completes; Unlock happens before the next Lock. Without such a relationship, behavior is undefined. Order:

Package-level variables are initialized in dependency order
Each file's init() functions run in lexical filename order
main() runs last (only in package main)

Multiple init functions in one file run in declaration order. t.Helper() marks a function as a test helper: failure messages report the caller's line number, not the helper's. Always call it in helpers like assertEqual to make test failures easier to read. Maps are key-value collections:
m := make(map[string]int)
m["age"] = 30
val, ok := m["age"] — the comma ok idiom checks if a key exists. Maps are not safe for concurrent access without synchronization.

Question 8 Go Programming

What is a method set in Go?

encoding/base64 encodes binary data as ASCII text for safe transport in JSON, URLs, or email:
base64.StdEncoding.EncodeToString([]byte("data"))
Variants: StdEncoding, URLEncoding (uses -_), RawStdEncoding / RawURLEncoding (no padding). Go's basic types include:

bool
string
int, int8, int16, int32, int64
uint, uint8, uint16, uint32, uint64
float32, float64
complex64, complex128
byte (alias for uint8), rune (alias for int32)

Enabled with go test -race or go run -race. It instruments memory accesses using ThreadSanitizer to detect data races at runtime. Adds ~5–10x overhead and ~2–20x memory cost, so use it in tests rather than production. The method set of a type is the set of methods defined for it. For value T it includes methods with receiver T. For pointer *T it includes both T and *T receivers. A type satisfies an interface only if all interface methods are in its method set.

Question 9 Go Programming

What are OS- and architecture-specific file names?

Go automatically includes files whose names end with _GOOS or _GOARCH for the current platform:
net_linux.go (Linux only)
asm_amd64.s (amd64 assembly)
Useful for platform-specific implementations. In Go, an identifier starting with an uppercase letter is exported (public) — accessible from other packages.
A lowercase identifier is unexported (private) — only accessible within its own package.
Example: Person is exported; person is unexported. Go's basic types include:

bool
string
int, int8, int16, int32, int64
uint, uint8, uint16, uint32, uint64
float32, float64
complex64, complex128
byte (alias for uint8), rune (alias for int32)

w.Header().Set("Content-Type", "application/json")
w.Header().Add("X-Custom", "v1")
Headers must be set before calling w.WriteHeader(code) or any w.Write call. Once the response is started, headers are immutable.

Question 10 Go Programming

How does error handling work in Go?

Go uses explicit error returns instead of exceptions:
result, err := doSomething()
if err != nil { log.Fatal(err) }
The error type is a built-in interface: type error interface { Error() string } A common Go testing pattern using a slice of test cases:

tests := []struct{ input int; want int }{
  {1, 2}, {2, 4},
}
for _, tt := range tests {
  t.Run(fmt.Sprint(tt.input), func(t *testing.T) {
    if got := Double(tt.input); got != tt.want {
      t.Errorf("got %d, want %d", got, tt.want)
    }
  })
}

When a slice has no spare capacity, append allocates a new underlying array. Growth strategy (Go 1.18+) typically doubles for small slices and grows by ~25% for larger ones (capped at 256), then follows a formula. This is amortized O(1) but causes occasional spikes. A package is Go's way of organizing code. Every Go file starts with package name. The main package with a func main() is the entry point. Exported identifiers start with an uppercase letter.

Question 11 Go Programming

What is the init function in Go?

Use close(ch) to signal that no more values will be sent. Receivers can detect this:
val, ok := <-ch — ok is false when closed.
A for range ch loop exits automatically when the channel is closed. Only the sender should close a channel. A type switch inspects the concrete type of an interface value:

switch v := i.(type) {
case int:
  fmt.Println("int:", v)
case string:
  fmt.Println("string:", v)
default:
  fmt.Println("unknown")
}

func init() runs automatically before main(). Each file can have multiple init functions. They are used for:

Setting up initial state
Registering drivers or plugins
Validating configuration

sort.SliceStable preserves the relative order of equal elements. Useful when sorting a slice of structs by one field while keeping secondary fields in their original order. Underlying algorithm is insertion sort (O(n²) worst case).

Question 12 Go Programming

What is the filepath package used for?

The context package manages deadlines, cancellation, and request-scoped values:
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
Pass ctx to functions and check ctx.Done() for cancellation. GOPATH is the legacy Go workspace location where dependencies and binaries lived before modules. With modules it is mostly irrelevant, but it still controls where go install puts binaries: typically ~/go by default. path/filepath builds and parses OS-specific paths:
filepath.Join("a", "b", "c.txt") → "a/b/c.txt" on Unix, "a\b\c.txt" on Windows.
filepath.Separator gives the OS separator.
Use path (without filepath) for slash-separated paths used in URLs. Prefix a function call with go to run it as a goroutine:

go func() {
  fmt.Println("running concurrently")
}()

The calling function does not wait for the goroutine to finish — use channels or sync.WaitGroup for synchronization.

Question 13 Go Programming

What is the scheduler's M:N model in Go?

Go's runtime uses an M:N scheduler that maps M goroutines onto N OS threads. Components:

G = goroutine
M = OS thread (machine)
P = logical processor holding a run queue

Work stealing between Ps keeps load balanced. Use the make function:
ch := make(chan int) — unbuffered
ch := make(chan string, 5) — buffered with capacity 5
Channels are used to communicate between goroutines safely. By default, json.Unmarshal silently ignores unknown fields. To make it strict, set a decoder option:
dec := json.NewDecoder(r)
dec.DisallowUnknownFields()
This causes an error if the JSON contains fields not present in the target struct. http.Handler is the interface every HTTP handler must satisfy:

type Handler interface {
  ServerHTTP(http.ResponseWriter, *http.Request)
}

Implement it on a struct to create handlers with state (e.g. dependencies, configuration).

Question 14 Go Programming

What is a pipeline pattern in Go?

Create a file ending in _test.go and use the testing package:

func TestAdd(t *testing.T) {
  if Add(2, 3) != 5 {
    t.Error("expected 5")
  }
}

Run with go test ./... sync.WaitGroup waits for a collection of goroutines to finish:
var wg sync.WaitGroup
wg.Add(1)
go func() { defer wg.Done(); work() }()
wg.Wait()
It acts as a concurrent counter. A pipeline chains stages, each consuming from an input channel and producing to an output:
gen → square → filter → sink
Each stage runs in its own goroutine, processing one element at a time. Use for range + close at each stage to propagate termination. http.HandlerFunc is a function type that implements http.Handler:
type HandlerFunc func(http.ResponseWriter, *http.Request)
It lets you use plain functions as handlers:
mux.HandleFunc("/", func(w, r) { ... })

Question 15 Go Programming

What is a struct in Go?

cgo lets Go call C code. Add a special comment:
// #include <stdio.h>
import "C"
Then call C functions through the C package. cgo has overhead, complicates builds, and disables some Go tooling — use sparingly. A pattern using a fixed number of goroutines reading jobs from a shared channel:
jobs := make(chan Job, 100)
for w := 0; w < numWorkers; w++ { go worker(jobs) }
Bounds concurrency, reduces goroutine creation overhead, and is the standard way to throttle parallel work. A struct is a composite type that groups fields:

type Person struct {
  Name string
  Age int
}

p := Person{Name: "Alice", Age: 30} Order:

Package-level variables are initialized in dependency order
Each file's init() functions run in lexical filename order
main() runs last (only in package main)

Multiple init functions in one file run in declaration order.

Question 16 Go Programming

What is a nil slice vs an empty slice?

Also called an anonymous function:
add := func(a, b int) int { return a + b }
Commonly used inline with go, defer, and callbacks. b.ResetTimer() discards time accumulated during expensive setup so the benchmark measures only the hot path. Always call it after any setup that should not count toward the result. Concurrency is about structuring a program to handle multiple tasks (goroutines, channels).
Parallelism is about executing multiple tasks simultaneously on multiple CPU cores.
Go makes concurrency easy; parallelism depends on GOMAXPROCS and available cores. Nil slice: var s []int → s == nil, length 0.
Empty slice: s := []int{} or make([]int, 0) → s != nil, length 0.
Most operations (range, append, len) behave identically. json.Marshal renders nil as null and empty as [].

Question 17 Go Programming

What is the select statement in Go?

a := b makes a and b share the same underlying array — changes to one are visible in the other.
copy(dst, src) copies elements into independent backing storage. The copy size is min(len(dst), len(src)). sync.Cond implements a condition variable — goroutines wait for or announce that a condition has occurred:
cond.L.Lock(); cond.Wait(); cond.Signal(); cond.Broadcast(). Rarely used directly; channels are usually preferred. select lets a goroutine wait on multiple channel operations:

select {
case msg := <-ch1:
  fmt.Println(msg)
case ch2 <- 42:
  fmt.Println("sent")
default:
  fmt.Println("no activity")
}

In Go, an identifier starting with an uppercase letter is exported (public) — accessible from other packages.
A lowercase identifier is unexported (private) — only accessible within its own package.
Example: Person is exported; person is unexported.

Question 18 Go Programming

What are Go's basic data types?

err := os.WriteFile("file.txt", data, 0644) writes a byte slice in one call.
For more control use os.Create to get a *os.File, then write with the file's Write or WriteString methods. The permission bits (e.g. 0644) are combined with the process umask. GOPATH is the legacy Go workspace location where dependencies and binaries lived before modules. With modules it is mostly irrelevant, but it still controls where go install puts binaries: typically ~/go by default. Go's basic types include:

bool
string
int, int8, int16, int32, int64
uint, uint8, uint16, uint32, uint64
float32, float64
complex64, complex128
byte (alias for uint8), rune (alias for int32)

A closure is a function that captures variables from its surrounding scope:

func counter() func() int {
  n := 0
  return func() int { n++; return n }
}

c := counter()
c() // 1
c() // 2
The returned function retains access to n.

Question 19 Go Programming

What is a deadlock and how does Go detect it?

bufio provides buffered I/O wrapping an io.Reader or io.Writer:
r := bufio.NewReader(file) — reads in chunks, reducing syscalls.
w := bufio.NewWriter(file) — buffers writes; call Flush() before closing.
scanner := bufio.NewScanner(file) — convenient line-by-line reading. time.Tick(d) returns a channel that delivers time.Time values at the specified interval:
for t := range time.Tick(time.Second) { fmt.Println(t) }
Note: it is intended for simple cases; time.NewTicker gives you explicit control to stop. A goroutine is a lightweight thread managed by the Go runtime. You start one with the go keyword:
go myFunction()
Goroutines are multiplexed onto OS threads and are extremely cheap to create (only a few KB of stack). A deadlock occurs when all goroutines are blocked waiting on each other. The Go runtime detects this and panics with fatal error: all goroutines are asleep - deadlock! Detection only works if all goroutines are blocked.

Question 20 Go Programming

What is the difference between w.Write and w.WriteHeader?

io.Reader: Read(p []byte) (n int, err error) — reads into p.
io.Writer: Write(p []byte) (n int, err error) — writes from p.
They are the cornerstone abstractions in Go I/O — files, network connections, buffers, and HTTP bodies all satisfy them. A type switch inspects the concrete type of an interface value:

switch v := i.(type) {
case int:
  fmt.Println("int:", v)
case string:
  fmt.Println("string:", v)
default:
  fmt.Println("unknown")
}

You can declare variables using:
var x int = 10
var y = "hello" (type inferred)
z := 42 (short declaration, only inside functions) w.Write([]byte) writes the response body. If no status has been sent, it implicitly sends 200 OK.
w.WriteHeader(404) sends the status code without a body. Call it before writing the body to set a non-200 status.

Question 21 Go Programming

What happens if you read a missing key from a map?

t.Cleanup(func()) registers a function to run after the test (or subtest) finishes. Similar to defer but scoped to the test, including all subtests. Useful for releasing resources shared across subtests. A deadlock occurs when all goroutines are blocked waiting on each other. The Go runtime detects this and panics with fatal error: all goroutines are asleep - deadlock! Detection only works if all goroutines are blocked. Reading a missing key returns the zero value of the value type — it does not panic:
val := m["nope"] // val is ""
Use the comma-ok idiom val, ok := m["key"] to distinguish missing from zero. sync.Pool is a cache of temporary objects designed to reduce allocation pressure. pool.Get() returns an object (creating one if needed), pool.Put(x) returns it. Pools are cleared at every GC, so do not rely on them for persistent state.

Question 22 Go Programming

How do you use generics in Go?

sync.Mutex is exclusive — one lock holder at a time.
sync.RWMutex allows multiple concurrent readers but only one writer. Call RLock()/RUnlock() for reads, Lock()/Unlock() for writes. Use RWMutex when reads dominate. Add a function func BenchmarkX(b *testing.B) in a _test.go file:
for i := 0; i < b.N; i++ { work() }
Run with go test -bench=.. The framework adjusts b.N until the result is statistically meaningful. Generics were added in Go 1.18 with type parameters:

func Map[T any, U any](s []T, f func(T) U) []U {
  result := make([]U, len(s))
  for i, v := range s {
    result[i] = f(v)
  }
  return result
}

Use type constraints to restrict allowed types. sort.Slice(s, func(i, j int) bool { return s[i] < s[j] }) sorts in place using a custom less function. Note: it is not guaranteed stable. For a stable sort, use sort.SliceStable with the same signature.

Question 23 Go Programming

What is the variadic function syntax?

sync.Mutex provides mutual exclusion for shared data:
var mu sync.Mutex
mu.Lock()
// critical section
mu.Unlock()
Use sync.RWMutex for multiple readers with a single writer pattern. Always use defer mu.Unlock() for safety. go mod vendor copies all dependencies into a vendor/ directory. Builds then use those vendored copies, ignoring the module cache. Useful for air-gapped or reproducible builds. Pass -mod=vendor to go build to use them. http.HandlerFunc is a function type that implements http.Handler:
type HandlerFunc func(http.ResponseWriter, *http.Request)
It lets you use plain functions as handlers:
mux.HandleFunc("/", func(w, r) { ... }) A variadic function accepts any number of a particular type's arguments using ...:
func sum(nums ...int) int { ... }
Inside the function, nums is a []int. Call with sum(1, 2, 3) or sum(slice...).

Question 24 Go Programming

What is the init order in Go packages?

Order:

Package-level variables are initialized in dependency order
Each file's init() functions run in lexical filename order
main() runs last (only in package main)

Multiple init functions in one file run in declaration order. A common Go testing pattern using a slice of test cases:

tests := []struct{ input int; want int }{
  {1, 2}, {2, 4},
}
for _, tt := range tests {
  t.Run(fmt.Sprint(tt.input), func(t *testing.T) {
    if got := Double(tt.input); got != tt.want {
      t.Errorf("got %d, want %d", got, tt.want)
    }
  })
}

Arrays have a fixed size that is part of their type: [3]int.
Slices are dynamically sized references to arrays: []int.
Slices are far more common. You can create a slice from an array: s := arr[1:3]. Reading a missing key returns the zero value of the value type — it does not panic:
val := m["nope"] // val is ""
Use the comma-ok idiom val, ok := m["key"] to distinguish missing from zero.

Question 25 Go Programming

What is GOMAXPROCS?

os.ReadFile(name) opens the file, reads it fully, and closes it — returns []byte.
io.ReadAll(r) reads fully from any io.Reader — useful for http.Response.Body, strings.Reader, etc. They are otherwise similar in result. GOMAXPROCS is an environment variable / function that sets the maximum number of OS threads that can execute Go code simultaneously. Default = runtime.NumCPU(). It limits parallelism, not concurrency — goroutines can still exist in greater numbers. Introduced in Go 1.16, embed lets you embed files into the binary:
import _ "embed"
//go:embed hello.txt
var s string
Files become variables. Useful for shipping templates, configs, and static assets with no runtime file dependency. new(T) allocates memory for type T and returns a pointer *T initialized to zero value.
make(T, args) is used only for slices, maps, and channels — it returns an initialized (not zeroed) value of type T, not a pointer.

Question 26 Go Programming

What is the uintptr type?

Create a 2D slice manually:
matrix := make([][]int, rows)

for i := range matrix {
  matrix[i] = make([]int, cols)
}

Go does not have built-in multidimensional arrays with dynamic sizes, so you compose slices of slices. runtime.Gosched() yields the current goroutine, allowing the scheduler to run other goroutines. The yielding goroutine is automatically resumed later. Useful when a tight loop might starve other goroutines. uintptr is an unsigned integer large enough to hold a pointer bit pattern. It is not a pointer — the GC does not track it. Used with unsafe.Pointer for pointer arithmetic; almost never needed in application code. bufio provides buffered I/O wrapping an io.Reader or io.Writer:
r := bufio.NewReader(file) — reads in chunks, reducing syscalls.
w := bufio.NewWriter(file) — buffers writes; call Flush() before closing.
scanner := bufio.NewScanner(file) — convenient line-by-line reading.

What is t.Helper used for?

What is a map iteration order?

How does the context package work?

What is the embed package?

How do you write a string with Unicode escapes?

How do you make an HTTP request in Go?

What is a happens-before relationship?

What is a method set in Go?

What are OS- and architecture-specific file names?

How does error handling work in Go?

What is the init function in Go?

What is the filepath package used for?

What is the scheduler's M:N model in Go?

What is a pipeline pattern in Go?

What is a struct in Go?

What is a nil slice vs an empty slice?

What is the select statement in Go?

What are Go's basic data types?

What is a deadlock and how does Go detect it?

What is the difference between w.Write and w.WriteHeader?

What happens if you read a missing key from a map?

How do you use generics in Go?

What is the variadic function syntax?

What is the init order in Go packages?

What is GOMAXPROCS?

What is the uintptr type?

What is the difference between make and new in Go?

What is the difference between go get and go install?

How does the os package's environment variable API work?

What is Go (Golang)?

What is cgo?

How does append grow a slice?

What is the time package's time.Time type?

What is the sema package used for?

How do pointers work in Go?

How do you handle panics in Go?

What is the difference between sync.Mutex and sync.RWMutex?

How do you close a channel and why?

How do you declare a variable in Go?

What is the difference between json.Marshal and json.Encoder?

How do you handle unknown JSON fields in Go?

What is the race detector in Go?

How do you create a custom error in Go?

What is a type switch in Go?

What is a singleflight in Go?

What is the underscore import in Go?

What is http.Handler?

What is go mod vendor?

How do interfaces work in Go?

What is an unsafe.Pointer?