Question 1

What is Go (Golang), and what are its main design goals?

Accepted Answer

Go is an open-source, statically-typed, compiled programming language designed by Google. Main design goals include simplicity, structural type safety, fast compilation, built-in concurrency support (Goroutines), and garbage collection. Go compiles directly to machine code, avoiding the need for a virtual machine.

Question 2

What is a Goroutine, and how does it differ from an OS thread?

Accepted Answer

A Goroutine is a lightweight thread of execution managed by the Go runtime, not the operating system. Goroutines have extremely small stack sizes (starting at ~2KB compared to an OS thread's ~1MB) and grow dynamically. The Go scheduler multiplexes thousands of Goroutines onto a small number of actual OS threads using M:N scheduling.
Code Example:
go myFunction() // Starts a new concurrent goroutine

Question 3

What are channels in Go, and how do they work?

Accepted Answer

Channels are typed conduits that allow Goroutines to communicate and synchronize execution by sending and receiving values. Channels prevent race conditions without needing explicit mutex locks, supporting Go's philosophy: 'Do not communicate by sharing memory; instead, share memory by communicating.'
Code Example:
ch := make(chan int) // Unbuffered channel
ch <- 42             // Send value to channel
val := <-ch         // Receive value from channel

Question 4

Explain Buffered vs Unbuffered channels.

Accepted Answer

Unbuffered channels have zero capacity; sending blocks until a receiver is ready, facilitating synchronous coordination. Buffered channels have a specified buffer capacity. Sends block only when the buffer is full, and receives block only when the buffer is empty, enabling asynchronous communication.
Code Example:
ch := make(chan string, 3) // Buffered channel with capacity 3
ch <- "A"
ch <- "B"
ch <- "C" // Sending works without a receiver waiting

Question 5

What is the difference between Array and Slice in Go?

Accepted Answer

An Array has a fixed size defined at declaration which cannot be changed, and is a value type. A Slice is a dynamic, variable-length view into an underlying array. A slice is a reference type containing a pointer to the array, a length (`len`), and a capacity (`cap`).
Code Example:
arr := [5]int{1, 2, 3, 4, 5} // Array of size 5
slice := arr[1:3]             // Slice referencing elements [2, 3]

Question 6

What happens when you append to a slice beyond its capacity?

Accepted Answer

When appending beyond a slice's capacity (`cap`), the Go runtime allocates a new underlying array with double the capacity (or 1.25x for larger slices), copies the existing elements over, appends the new element, and returns a new slice pointing to the new array.

Question 7

How does Go handle error propagation?

Accepted Answer

Go does not use exceptions (try-catch). Errors are treated as normal values. Functions that can fail return an `error` interface as the last return parameter, which the caller checks explicitly.
Code Example:
file, err := os.Open("test.txt")
if err != nil {
    log.Fatal(err)
}
// Proceed with file usage

Question 8

Explain the `defer` keyword in Go.

Accepted Answer

The `defer` statement schedules a function call to be executed immediately *after* the surrounding function returns. Deferred calls are executed in Last-In-First-Out (LIFO) order. It is commonly used for resource cleanup (closing files, releasing locks).
Code Example:
func readFile() {
    file, _ := os.Open("data.txt")
    defer file.Close() // Guaranteed to run before readFile exits
    // ... read file
}

Question 9

What is the empty interface `interface{}` (any) in Go?

Accepted Answer

The empty interface `interface{}` specifies zero methods. Since all types implement at least zero methods, the empty interface can hold values of any type, making it Go's generic variable container (aliased as `any` in Go 1.18+).

Question 10

What is a Struct pointer receiver versus a value receiver?

Accepted Answer

Value receivers work on a *copy* of the struct; modifications made inside the method do not affect the original caller. Pointer receivers (`*T`) operate on the *actual memory reference* of the struct, allowing methods to modify struct fields directly and avoiding copying overhead for large structures.
Code Example:
type User struct { Name string }

// Value receiver
func (u User) UpdateName(n string) { u.Name = n } // No effect outside

// Pointer receiver
func (u *User) SetName(n string) { u.Name = n }     // Modifies original

Question 11

How does Go handle garbage collection?

Accepted Answer

Go uses a concurrent, tri-color mark-and-sweep garbage collector. It runs concurrently with the application threads (low latency) to minimize 'Stop-The-World' (STW) pauses. It relies on write barriers to track pointer changes during marking phases.

Question 12

What is the `select` statement in Go?

Accepted Answer

The `select` statement lets a Goroutine wait on multiple communication channel operations. It blocks until one of its cases can proceed, and executes it. If multiple are ready, it picks one randomly.
Code Example:
select {
case msg1 := <-ch1:
    fmt.Println("Received:", msg1)
case ch2 <- 42:
    fmt.Println("Sent to ch2")
default:
    fmt.Println("No channel ready")
}

Question 13

What is a race condition, and how does Go help detect it?

Accepted Answer

A race condition occurs when two or more Goroutines access shared memory concurrently, and at least one access is a write. Go includes a built-in data race detector enabled by compiling or testing code with the `-race` flag.
Code Example:
go test -race ./...
go run -race main.go

Question 14

Explain `sync.WaitGroup` and how it is used.

Accepted Answer

`sync.WaitGroup` is used to wait for a collection of Goroutines to finish executing. The main thread calls `Add` to set count, launches Goroutines which call `Done` on completion, and calls `Wait` to block until all goroutines finish.
Code Example:
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
    wg.Add(1)
    go func() {
        defer wg.Done()
        // Perform work
    }()
}
wg.Wait() // Blocks until count becomes 0

Question 15

What is Go's module system (go.mod)?

Accepted Answer

Go Modules is the official dependency management system in Go. The `go.mod` file defines the module's path and lists dependency packages with explicit semantic versions. The `go.sum` file lists cryptographic hashes of dependencies to ensure builds are reproducible.

Question 16

What is a slice header?

Accepted Answer

A slice header is the internal runtime structure of a slice. It is a 24-byte header containing three fields: a pointer to the backing array, a length integer, and a capacity integer. Passing a slice to a function copies this header, not the backing array.

Question 17

Explain panic and recover in Go.

Accepted Answer

`panic` stops the ordinary flow of control and starts panicking (unwinding the call stack, running deferred functions). `recover` is a built-in function that regains control of a panicking Goroutine. Recover is only useful when called inside a deferred function.
Code Example:
defer func() {
    if r := recover(); r != nil {
        fmt.Println("Recovered from panic:", r)
    }
}()
panic("critical error")

Question 18

What is a Mutex (`sync.Mutex`), and how does it differ from `sync.RWMutex`?

Accepted Answer

`sync.Mutex` is a mutual exclusion lock. Only one Goroutine can hold the lock at any time. `sync.RWMutex` is a reader-writer lock. It allows multiple readers to hold the lock simultaneously as long as no writer holds it, optimizing performance for read-heavy workloads.

Question 19

Explain Go's implementation of interfaces (implicit implementation).

Accepted Answer

In Go, interfaces are satisfied implicitly. A concrete type does not need to declare that it implements an interface (there is no `implements` keyword). If a type defines all the methods signature declared by an interface, the compiler automatically allows assigning it to that interface.

Question 20

Explain escape analysis in Go compilation.

Accepted Answer

Escape analysis is a compiler optimization phase that determines whether a variable's memory can be allocated on the function's stack frame or if it must 'escape' to the heap. If a variable is referenced outside the stack scope (e.g. returning a pointer to local variable), it is allocated on the heap.

Go (Golang) Interview Master

Difficulty Filters

Tools & Options

What is Go (Golang), and what are its main design goals?

What is a Goroutine, and how does it differ from an OS thread?

What are channels in Go, and how do they work?

Explain Buffered vs Unbuffered channels.

What is the difference between Array and Slice in Go?

What happens when you append to a slice beyond its capacity?

How does Go handle error propagation?

Explain the `defer` keyword in Go.

What is the empty interface `interface{}` (any) in Go?

What is a Struct pointer receiver versus a value receiver?

How does Go handle garbage collection?

What is the `select` statement in Go?

What is a race condition, and how does Go help detect it?

Explain `sync.WaitGroup` and how it is used.

What is Go's module system (go.mod)?

What is a slice header?

Explain panic and recover in Go.

What is a Mutex (`sync.Mutex`), and how does it differ from `sync.RWMutex`?

Explain Go's implementation of interfaces (implicit implementation).

Explain escape analysis in Go compilation.

Technical Interview Mastery Blueprint

1. The Engineering STAR Technique

2. Defending Architectural Trade-Offs

3. Clean Code & Edge-Case Proactivity

4. Antipatterns to Avoid

Explore Related Tools

Angular Interview Questions

Aws Interview Questions

Bootstrap Interview Questions

Dsa Interview Questions

Lld Interview Questions

Nextjs Interview Questions

Follow Us

Our Tools

Our Company

Special Tools