20 Advanced Rust Backend Interview Questions and Answers for Senior Role

Goroutines are lightweight threads managed by the Go runtime. They are much cheaper than OS threads, starting with only a few kilobytes of stack space that grows and shrinks as needed. Millions of goroutines can run on a small number of OS threads, making concurrent programming in Go highly efficient.

The Go scheduler uses a model with three main concepts:

• G (Goroutine): Represents a single goroutine with its stack and instruction pointer.
• M (Machine): An OS thread that executes the code.
• P (Processor): A context required for executing Go code. It can be thought of as a CPU core available to the scheduler.

The scheduler’s job is to distribute runnable Gs across available Ms and Ps to achieve concurrency.

Use channels when you need to communicate data or orchestrate execution between goroutines. They are the idiomatic Go way: “Do not communicate by sharing memory; instead, share memory by communicating.” Use mutexes (sync.Mutex) when you need to protect a shared piece of memory from concurrent access within a single goroutine or when the logic is too complex for a channel-based approach.

A `select` statement blocks until one of its cases can run. If multiple cases are ready simultaneously, it chooses one at random to proceed. This prevents starvation and allows a goroutine to wait on multiple communication operations. A `default` case can be added to make the `select` non-blocking.

The `context` package is used to manage cancellation signals, deadlines, and request-scoped values across API boundaries and between goroutines. It’s essential for controlling long-running operations, such as database queries or HTTP requests, especially for implementing timeouts and graceful shutdowns.

Common patterns include:

• Generator: A function that returns a channel, pushing a sequence of values to it.
• Worker Pool: A fixed number of goroutines processing tasks from a shared channel.
• Fan-in, Fan-out: Distributing work to multiple goroutines (fan-out) and collecting the results into a single channel (fan-in).
• Rate Limiting: Using a ticker or a token bucket to control the frequency of operations.

new(T) allocates memory for a new item of type `T`, zeroes the memory, and returns a pointer to it (*T).

make(T, ...) is only used for creating slices, maps, and channels. It initializes the internal data structures of these types and returns an initialized (not zeroed) value of type `T` (not `*T`).

An array is a fixed-size sequence of elements of a particular type. A slice is a flexible, dynamically-sized view into the elements of an array. A slice is a struct containing three fields: a pointer to the underlying array, a length, and a capacity. Slices are much more common and versatile in Go than arrays.

An interface is a type that specifies a set of method signatures. A type implements an interface by implementing its methods—no `implements` keyword is needed (this is called structural typing). This allows for writing flexible, decoupled code, making it easy to create mocks for testing and build generic systems. The empty interface, `interface{}`, can hold a value of any type.

A `defer` statement pushes a function call onto a list. The list of saved calls is executed after the surrounding function returns. `defer` is commonly used to simplify functions that perform clean-up operations, such as closing files or unlocking mutexes, ensuring that the cleanup code runs regardless of how the function exits.

Struct embedding is Go’s approach to composition, allowing you to include one struct type within another. The methods and fields of the embedded struct are “promoted” to the containing struct, making them directly accessible. It’s a way to achieve code reuse and is often preferred over classical inheritance.

In Go, errors are values. The idiomatic approach is for functions to return an `error` as their last return value. The caller is expected to check if the error is non-`nil`. Since Go 1.13, the `errors` package supports wrapping errors to add context (`fmt.Errorf` with `%w`) and inspecting error chains with `errors.Is` and `errors.As`.

Build tags are comments placed at the top of a Go source file that control when the file is included in a build. They allow you to compile different code for different operating systems, architectures, or custom build modes (e.g., enabling integration tests). The syntax is `//go:build tag`.

Go modules are how Go manages dependencies. A module is a collection of Go packages stored in a file tree with a `go.mod` file at its root. The `go.mod` file defines the module’s path and its dependency requirements. The `go` tool uses this file to download dependencies and ensure reproducible builds.

Go uses a concurrent, tri-color mark-and-sweep garbage collector. It runs concurrently with the user program and is designed for very low latency, typically with “stop-the-world” pauses under a millisecond. It identifies and reclaims memory that is no longer reachable by the application.

Escape analysis is a compile-time process that determines whether a variable can be allocated on the function’s stack or must be “escaped” to the heap. Stack allocation is much faster and avoids GC overhead. A variable escapes if its lifetime extends beyond the function’s return, such as when its pointer is returned or captured in a closure.

Go has excellent built-in tooling for profiling. I would use the `pprof` tool to capture and analyze:

• CPU profiles: To find functions consuming the most CPU time.
• Heap profiles: To analyze memory allocation and find potential leaks.
• Goroutine profiles: To debug blocked or leaked goroutines.

Optimization involves reducing allocations, improving algorithms, and using concurrency effectively based on profiling data.

A `sync.Pool` is a concurrent-safe pool of temporary objects. Its purpose is to reuse objects to reduce pressure on the garbage collector. It’s particularly useful for managing large numbers of short-lived objects, like buffers for I/O operations, but should be used only after profiling has identified a performance bottleneck due to allocations.

To implement a graceful shutdown, you listen for an OS interrupt signal (like `SIGINT`). Upon receiving the signal, you call the `http.Server.Shutdown()` method. This method gracefully shuts down the server without interrupting any active connections. It stops accepting new requests and waits for existing ones to complete, using a `context` for a timeout.

Go’s standard `database/sql` package handles connection pooling automatically. When you call `sql.Open()`, you get a handle (`*sql.DB`) that represents a pool of connections. You can configure the pool’s behavior with methods like `SetMaxOpenConns`, `SetMaxIdleConns`, and `SetConnMaxLifetime` to optimize for your application’s workload.

Pros:

• Excellent performance and low memory footprint.
• Built-in concurrency primitives make handling many requests easy.
• Fast compile times and static binary deployment simplify CI/CD.
• A strong standard library for networking (net/http).

Cons:

• Less mature ecosystem compared to Java or Python.
• Verbose error handling can be tedious for some developers.
• Lack of generics before Go 1.18 made some reusable code harder to write.

The standard library’s `encoding/json` package is used for JSON handling. `json.Marshal` converts a Go struct into a JSON byte slice, and `json.Unmarshal` parses a JSON byte slice into a Go struct. Struct field tags (e.g., `json:"fieldName"`) are used to map struct fields to JSON keys.

A simple in-memory rate limiter can be built using a map to store timestamps for each user/IP and a mutex for safe concurrent access. For a more robust and efficient solution, the `golang.org/x/time/rate` package provides a token bucket algorithm implementation. For a distributed system, an external store like Redis would be used to maintain state across multiple service instances, often using atomic operations.