Design a graceful worker pool in Go
WHAT IT TESTS: concurrency coordination with goroutines, channels, and context. OUTLINE: buffered job channel, fixed worker goroutines, WaitGroup to await in-flight work, context cancellation to stop intake.
cgo threading challenges with multi-threaded C libraries
WHAT IT TESTS: understanding of the Go-to-C boundary and threading. OUTLINE: cgo calls run on a dedicated OS thread and detach the P; thread-local state and callbacks into Go are fragile; solutions include LockOSThread, minimizing crossings, and a dedicated…
Cancellation and cleanup: Go context/errgroup vs Tokio
WHAT IT TESTS: structured-concurrency cancellation knowledge. OUTLINE: Go propagates cancellation via context.Context that goroutines must poll, with errgroup canceling siblings on first error; Tokio cancels by dropping futures, which stops them at await…
Go scheduler work-stealing and blocking syscalls
WHAT IT TESTS: knowledge of the Go runtime scheduler internals. OUTLINE: the GMP model runs goroutines (G) on OS threads (M) attached to logical processors (P); idle P's steal half of another P's run queue; on a blocking syscall the M detaches with its G.
Implicit Go interfaces versus explicit Rust trait impls
WHAT IT TESTS: understanding of conformance models and maintainability. OUTLINE: Go's implicit satisfaction enables decoupling and retrofitting but hides who implements what and risks accidental conformance; Rust's explicit impls aid discovery, refactoring…
anyhow versus thiserror in Rust error handling
WHAT IT TESTS: idiomatic error-design judgment. OUTLINE: anyhow gives one opaque dynamic error type for applications where you mostly propagate and report; thiserror derives concrete typed enums for libraries so callers can match on variants.
Go if err != nil versus Rust's ? operator
WHAT IT TESTS: judgment on error-handling ergonomics. OUTLINE: Go's explicit checks are verbose but make every error site visible; Rust's ? propagates concisely while still forcing the error into the type, reducing boilerplate.
Designing a logging abstraction: Go interfaces vs Rust traits
WHAT IT TESTS: ability to design polymorphic abstractions and explain dispatch. OUTLINE: define a Logger interface/trait with a write method; Go interfaces are always dynamically dispatched; Rust lets you choose static dispatch (impl Trait/generics) or…
Go slices versus Rust Vec growth and reallocation
WHAT IT TESTS: understanding of dynamic-array internals. OUTLINE: both are a (pointer, length, capacity) triple over a heap buffer that reallocates and copies on growth, roughly doubling; key difference is Go slices share backing arrays and have no ownership…
Go interfaces versus Rust traits and macros at scale
WHAT IT TESTS: connecting language philosophy to ecosystem patterns. OUTLINE: Go uses reflection over interface{} (e.g. encoding/json) for runtime flexibility; Rust uses traits plus derive/proc macros (e.g. serde) for compile-time, zero-cost code generation.
Go's mandatory runtime versus Rust's minimal runtime
WHAT IT TESTS: understanding of runtime cost and its limits. OUTLINE: Go ships a GC and goroutine scheduler in every binary, ideal for services; Rust has only a tiny runtime and no GC, enabling embedded, kernels, and WASM.
Go interface-constraint generics versus Rust trait bounds
WHAT IT TESTS: understanding of generics design and monomorphization. OUTLINE: Go constrains type parameters with interfaces and may use dictionaries/shape stenciling; Rust uses trait bounds with full monomorphization for zero-cost specialization.
Go (T, error) versus Rust Result for error handling
WHAT IT TESTS: understanding of explicit error models. OUTLINE: Go returns a separate error value you may ignore; Rust wraps success or error in one Result enum the compiler forces you to handle. Go favors simplicity, Rust favors compile-enforced safety.
Goroutines and channels versus ownership-based concurrency
WHAT IT TESTS: understanding of two concurrency philosophies. OUTLINE: Go uses cheap goroutines and CSP-style channels to coordinate by communication; Rust uses ownership plus Send/Sync to make data races a compile error.
Structural Go interfaces versus nominal Rust traits
WHAT IT TESTS: grasp of typing models and their design impact. OUTLINE: Go interfaces are satisfied implicitly by method shape (structural); Rust traits must be explicitly implemented (nominal).
Criterion: the standard Rust benchmarking library
WHAT IT TESTS: ecosystem awareness and rigor about measurement. OUTLINE: Criterion runs on stable Rust, collects many samples, applies statistical analysis with confidence intervals, and compares against saved baselines to detect regressions.
Rust lifetimes versus Go garbage-collected lifetimes
WHAT IT TESTS: understanding of how Rust tracks reference validity. OUTLINE: a lifetime is a compile-time region a reference is valid for; annotations like 'a relate input and output reference durations; Go instead uses garbage collection and escape analysis.
Fearless concurrency: Rust compile-time vs Go runtime
WHAT IT TESTS: understanding of where each language catches concurrency bugs. OUTLINE: Rust uses ownership plus Send/Sync to reject data races at compile time; Go encourages channels but still allows races, with the runtime race detector catching them at test…
Why Pin is needed for self-referential Futures
WHAT IT TESTS: deep grasp of async internals. OUTLINE: async blocks compile to state machines that can hold references into their own storage; Pin guarantees the value will not move so those internal pointers stay valid across polls.
Architecting an L7 proxy in Go versus Rust
WHAT IT TESTS: ability to weigh systems trade-offs under real constraints. OUTLINE: Go offers GC and cheap goroutines for fast delivery but tail-latency GC pauses; Rust offers ownership and async/await for predictable latency at higher complexity.