Go

How to answer in an interview

Go, also known as Golang, is a statically-typed, compiled programming language designed at Google. Key features include a simple and clean syntax, built-in concurrency via goroutines and channels, garbage collection, fast compilation, and a powerful standard library. It excels at building networked services, CLI tools, and distributed systems.

Explain like I am 5

Go is a programming language that's fast to both run and write — it's like a clean, simple toolbox that also comes with built-in helpers for doing many things at the same time.

How to answer in an interview

Slices are dynamic, flexible views into an underlying array, with a length and capacity that can change as elements are added or removed. Arrays in Go have a fixed size determined at compile time and cannot be resized. Slices are far more commonly used because of their flexibility, and they're passed by reference (as a header containing a pointer, length, and capacity) rather than by value.

Explain like I am 5

A slice is like a movable window over a fixed-size shelf — you can shift the window to see different parts and even expand it, while an array is the fixed shelf itself that never changes size.

How to answer in an interview

The defer keyword schedules a function call to be executed after the surrounding function returns, typically used for cleanup tasks like closing files or releasing locks. Defers are evaluated immediately when the defer statement is encountered but executed in LIFO (last-in, first-out) order after the function returns.

Explain like I am 5

Defer is like adding items to a 'to-do-after-finish' list — the last thing you add gets done first when you're done, ensuring nothing important is forgotten.

How to answer in an interview

Go uses explicit error handling via the built-in error interface, where functions return an error as an additional return value that must be checked by the caller. There are no exceptions or try/catch blocks. Common patterns include returning nil for no error, wrapping errors with context using fmt.Errorf, and comparing against sentinel errors using errors.Is or errors.As.

Explain like I am 5

In Go, every function that might fail hands you a little note saying whether something went wrong. You always check the note instead of hoping nothing bad happens.

How to answer in an interview

Go modules are the official dependency management system for Go, introduced to replace GOPATH-based workflows. A go.mod file defines the module's path and its dependencies with specific versions, while go.sum records cryptographic checksums to ensure reproducibility. Modules allow precise version pinning, private repository support, and vendoring.

Explain like I am 5

Go modules are like a shopping list and recipe for your project — they record exactly which external tools you need and which versions, so your project builds the same way every time.

How to answer in an interview

The blank identifier (_) is used to ignore values you don't need, such as when a function returns two values but you only need one. Named return values pre-declare return variables with their names, allowing you to return implicitly without explicit return values and to use naked returns for short functions, though explicit returns are generally preferred for clarity.

Explain like I am 5

The blank identifier is like saying 'I don't need this piece' and tossing it aside. Named returns let you label your answers so you can just say 'done' at the end instead of restating the answers.

How to answer in an interview

Strings in Go are immutable sequences of bytes, typically representing UTF-8 text. A []byte is a mutable slice of bytes. Converting between them involves a copy (strings(b) or []byte(s)) because they have different memory layouts and mutability semantics. Strings are preferred for text; []byte for raw binary data or when mutation is needed.

Explain like I am 5

A string is like a printed message you can read but not change. A []byte is like a list of individual letters you can edit, rearrange, or replace as needed.

How to answer in an interview

Goroutines are lightweight concurrency primitives managed by the Go runtime, not the operating system. They start with a small stack (a few KB) that grows and shrinks as needed, and thousands can run on a single OS thread. OS threads are heavier, with larger fixed stacks and higher context-switching costs managed by the kernel.

Explain like I am 5

Goroutines are like tiny, cheap workers that the Go language itself manages — you can spin up thousands of them without needing a powerful computer, unlike heavier OS threads that take more resources.

How to answer in an interview

Channels are used for communication and synchronization between goroutines, following the philosophy 'don't communicate by sharing memory; share memory by communicating.' A mutex (mutual exclusion lock) protects shared data by ensuring only one goroutine accesses it at a time. Channels are preferred for coordinating work, while mutexes protect critical sections when shared state is necessary.

Explain like I am 5

A channel is like a conveyor belt where goroutines pass messages to each other. A mutex is like a lock on a shared drawer — only one person can open it at a time.

How to answer in an interview

In Go, interfaces are satisfied implicitly — a type implements an interface simply by having the required methods, with no explicit 'implements' keyword needed. This is different from languages like Java or C# where classes must explicitly declare which interfaces they implement. Go interfaces tend to be small and focused, often containing just one or two methods.

Explain like I am 5

In Go, you don't need to announce you're following a contract — if your type has the right methods, Go just knows it fits the interface, like automatically qualifying for a club without filling out an application.

How to answer in an interview

A value receiver method operates on a copy of the value, so any modifications inside the method don't affect the original value. A pointer receiver method operates on a pointer to the original value, allowing the method to modify the receiver. Pointer receivers are also more efficient for large structs since they avoid copying the entire struct.

Explain like I am 5

A value receiver is like working on a photocopy — changes don't affect the original. A pointer receiver is like working on the original document itself — any edits are real.

How to answer in an interview

The select statement blocks until one of its cases can proceed, then executes that case. It's used to multiplex across multiple channel operations, choosing whichever channel is ready first. If multiple cases are ready, one is chosen pseudo-randomly. A default case makes select non-blocking, executing immediately if no channel operation is ready.

Explain like I am 5

Select is like waiting at a multi-lane checkout — you go to whichever lane opens up first, and if none are ready, you can walk away if there's a default option.

How to answer in an interview

The context package carries deadlines, cancellation signals, and request-scoped values across API boundaries and goroutine chains. It allows parent operations to cancel child goroutines when a request times out or the client disconnects, preventing resource leaks. Context is typically passed as the first argument to functions performing I/O or RPC calls.

Explain like I am 5

Context is like carrying an instruction note that says 'if I say stop, you stop too' — it lets a parent operation tell all its child tasks to cancel if something goes wrong.

How to answer in an interview

The sync package provides concurrency primitives for cases where goroutines and channels aren't the best fit. sync.Mutex and sync.RWMutex protect shared state from concurrent access. sync.WaitGroup lets you wait for a collection of goroutines to finish. sync.Once ensures a function runs exactly once across all goroutines, useful for initialization.

Explain like I am 5

The sync package is like a set of coordination tools — a lock to protect shared items, a counter to know when everyone's done, and a one-time-use stamp to make sure something only happens once.

How to answer in an interview

The embed package allows Go programs to embed static files, templates, or other assets directly into the compiled binary at build time using the //go:embed directive. This eliminates the need to distribute separate asset files alongside the binary and is useful for configuration files, default templates, and small datasets that should be bundled with the application.

Explain like I am 5

The embed package lets you pack files like templates or configs right inside your program when you build it, so you only need to ship one single file.

How to answer in an interview

Closures in Go are anonymous functions that capture and use variables from their enclosing lexical scope. They're commonly used for callbacks, goroutine arguments, stateful iteration, and customizing behavior without defining a full named function. Closures can also capture and modify variables, creating shared mutable state.

Explain like I am 5

A closure is like a mini-function that carries a small backpack of variables from where it was born, remembering them even after leaving that place.

How to answer in an interview

Go has a built-in testing package. Test functions start with Test and accept *testing.B. Benchmark functions start with Benchmark and accept *testing.B, using b.N for iteration count. Run tests with go test, benchmarks with go test -bench, and race detection with -race. Table-driven tests are a common Go idiom for testing multiple cases cleanly.

Explain like I am 5

Go comes with its own built-in test runner — you write functions that start with Test or Benchmark, and Go automatically finds and runs them for you.

How to answer in an interview

A type assertion extracts the underlying value from an interface, using the syntax x.(T). If the interface doesn't hold that type, it panics unless you use the comma-ok idiom (v, ok := x.(T)). A type switch lets you branch on the underlying type of an interface value in a switch-like structure, making it cleaner to handle multiple possible types.

Explain like I am 5

A type assertion is like asking 'is this box actually holding a ball?' and getting either the ball or a 'no.' A type switch is like checking a box against a list of possible items to see what's inside.

How to answer in an interview

Go uses an automatic tricolor mark-and-sweep garbage collector that runs concurrently with the application, minimizing pause times. The compiler performs escape analysis at build time to determine whether variables should be allocated on the stack (fast, automatic cleanup) or heap (needs GC). Stack allocation is strongly preferred, and the GC is optimized for low-latency concurrent workloads.

Explain like I am 5

Go has an automatic cleaning robot that runs alongside your program to pick up unused memory — it's designed to be fast enough that it doesn't noticeably slow your program down.

How to answer in an interview

go generate runs commands specified in //go:generate comments within Go source files, commonly used for code generation tasks like generating stringer methods, mock implementations, or protobuf bindings. It's not run automatically during build — you must explicitly invoke go generate, and the generated code is checked into version control.

Explain like I am 5

go generate is like a recipe card inside your code that tells the computer to automatically write certain repetitive code for you when you run a specific command.