Q: What is the difference between buffered and unbuffered channels?

- Unbuffered channels: Have no capacity to store values. Sends block until a receiver reads from the channel, and vice versa. - Buffered channels: Have a set capacity (e.g., `make(chan int, 10)`). Sends only block when the buffer is full, and receives only block when the buffer is empty.

Q: Explain error handling in Go and the role of the error interface.

Go does not support exception try-catch blocks. Instead, errors are returned explicitly as the last return value from functions. The built-in `error` is an interface representing any type that implements a single `Error() string` method. Checking errors involves simple conditionals: ```go val, err := doSomething() if err != nil { return err } ```

Q: What is the defer statement in Go and when is it executed?

The `defer` statement schedules a function call to be executed after the surrounding function returns. Deferred calls are evaluated immediately but executed in Last-In-First-Out (LIFO) order, which is ideal for cleaning up resources like closing files or database connections.

Q: Explain the difference between Slices and Arrays in Go.

- Arrays: Have a fixed length defined at compile time (e.g. `[5]int`), and their size is part of their type. - Slices: Are dynamic wrappers around arrays, containing a pointer to the array, a length, and a capacity (e.g. `[]int`). Slices can grow dynamically using the `append()` function.

Q: What is a Struct in Go?

A Struct is a user-defined type representing a collection of fields. Go does not have classes; instead, you define structs to model data, and attach methods to them using receiver functions.

Q: Explain receiver functions and the difference between value and pointer receivers.

- Value receivers (`func (u User) Name()`) receive a copy of the struct, meaning modifications inside the method do not affect the original instance. - Pointer receivers (`func (u *User) SetName(...)`) receive a reference pointer, letting you modify the original struct.

Q: What is the select statement in Go concurrency?

The `select` statement lets a goroutine wait on multiple communication operations on channels. It blocks until one of its cases is ready to execute. If multiple are ready, it chooses one randomly.

Question 1

What is Golang and what are its key features?

Accepted Answer

Golang (Go) is an open-source, statically typed, compiled programming language developed by Google. Its key features include simplicity (only 25 keywords), strong concurrency primitives (goroutines and channels), garbage collection, static compilation into single binaries, and strict compilation rules (unused imports or variables throw compile errors).

Question 2

Explain Goroutines and how they differ from standard OS threads.

Accepted Answer

Goroutines are lightweight threads managed by the Go runtime, not the OS. Spawning a goroutine uses only ~2KB of stack space, which can grow and shrink dynamically. OS threads typically require 1MB of stack space and involve expensive context switches. Go's runtime multiplexes millions of goroutines onto a small number of OS threads using an M:N scheduler.

Question 3

What are Channels in Go and how are they used?

Accepted Answer

Channels are typed conduits through which you can send and receive values using the channel operator (`<-`). They are used to synchronize goroutines and share data safely without explicit locks. By default, channels are unbuffered: sends and receives block until the other side is ready, enforcing synchronization.

Question 4

What is the difference between buffered and unbuffered channels?

Accepted Answer

- Unbuffered channels: Have no capacity to store values. Sends block until a receiver reads from the channel, and vice versa.
- Buffered channels: Have a set capacity (e.g., `make(chan int, 10)`). Sends only block when the buffer is full, and receives only block when the buffer is empty.

Question 5

Explain error handling in Go and the role of the error interface.

Accepted Answer

Go does not support exception try-catch blocks. Instead, errors are returned explicitly as the last return value from functions. The built-in `error` is an interface representing any type that implements a single `Error() string` method. Checking errors involves simple conditionals:
```go
val, err := doSomething()
if err != nil {
    return err
}
```

Question 6

What is the defer statement in Go and when is it executed?

Accepted Answer

The `defer` statement schedules a function call to be executed after the surrounding function returns. Deferred calls are evaluated immediately but executed in Last-In-First-Out (LIFO) order, which is ideal for cleaning up resources like closing files or database connections.

Question 7

Explain the difference between Slices and Arrays in Go.

Accepted Answer

- Arrays: Have a fixed length defined at compile time (e.g. `[5]int`), and their size is part of their type.
- Slices: Are dynamic wrappers around arrays, containing a pointer to the array, a length, and a capacity (e.g. `[]int`). Slices can grow dynamically using the `append()` function.

Question 8

What is a Struct in Go?

Accepted Answer

A Struct is a user-defined type representing a collection of fields. Go does not have classes; instead, you define structs to model data, and attach methods to them using receiver functions.

Question 9

Explain receiver functions and the difference between value and pointer receivers.

Accepted Answer

- Value receivers (`func (u User) Name()`) receive a copy of the struct, meaning modifications inside the method do not affect the original instance.
- Pointer receivers (`func (u *User) SetName(...)`) receive a reference pointer, letting you modify the original struct.

Question 10

What is the select statement in Go concurrency?

Accepted Answer

The `select` statement lets a goroutine wait on multiple communication operations on channels. It blocks until one of its cases is ready to execute. If multiple are ready, it chooses one randomly.

Question 11

Explain the blank identifier (_) in Go.

Accepted Answer

The blank identifier `_` is a write-only variable used to discard values returned from expressions (like unused return variables or import packages), satisfying Go's strict unused variables compilation rules.

Question 12

What is an Interface in Go and how is it implemented?

Accepted Answer

An Interface defines a set of method signatures. In Go, interfaces are implemented implicitly: if a type implements all the methods defined in an interface, it automatically implements the interface without needing an explicit `implements` keyword.

Question 13

Explain the make() and new() built-in functions.

Accepted Answer

- `new(T)` allocates zeroed memory for type `T` and returns a pointer of type `*T`.
- `make(T, args)` is used exclusively to initialize slices, maps, and channels, returning an initialized instance of type `T` (not a pointer).

Question 14

What are packages in Go?

Accepted Answer

Packages organize Go source files into directories. Every Go file must start with a `package` declaration. Executable programs must use `package main` and define a `main()` entrypoint function.

Question 15

Explain maps in Go and how to verify if a key exists.

Accepted Answer

Maps are hash tables. You check if a key exists using the two-value assignment pattern:
```go
value, ok := myMap["key"]
if !ok {
    // key does not exist
}
```

Question 16

What is the purpose of go.mod and go.sum files?

Accepted Answer

`go.mod` initializes module dependency tracking, declaring dependency ranges. `go.sum` contains cryptographic hashes of specific dependency versions, ensuring reproducible builds.

Question 17

Explain constants in Go.

Accepted Answer

Constants are declared with `const` and must be compile-time values. Go supports untyped constants, which can take types dynamically based on contexts without explicit casting.

Question 18

Explain Go's M:N scheduler (GMP model) and how it coordinates concurrency.

Accepted Answer

Go's runtime schedules Goroutines (`G`) onto Logical Processors (`P`), which map to OS Threads (`M`). The scheduler uses a work-stealing algorithm: if a thread `M` runs out of goroutines, it steals work from other threads' run queues, maximizing CPU cores.

Question 19

Explain Go Mutexes (sync.Mutex and sync.RWMutex) and when to use each.

Accepted Answer

- `sync.Mutex` blocks all access to a critical resource, allowing only one goroutine lock at a time.
- `sync.RWMutex` allows multiple concurrent readers but only one writer, which is optimal for read-heavy state caches.

Question 20

How do you handle timeouts in Go concurrency using context?

Accepted Answer

Create a context with a timeout: `ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)`. Pass this context to APIs and check for cancellation inside select blocks: `case <-ctx.Done():`.

Question 21

How do you write unit tests and benchmark tests in Go?

Accepted Answer

Write tests in files named `_test.go` using the `testing` package. Unit tests use `func TestX(t *testing.T)`. Benchmark tests use `func BenchmarkX(b *testing.B)` containing loops running `b.N` times to measure durations.

Question 22

Explain panic, recover, and defer in Go exception handling.

Accepted Answer

`panic` stops normal execution, unwinding the stack and running deferred functions. A deferred function can call `recover()` to capture the panic object and resume execution, preventing process crashes.

Question 23

What is the Go Garbage Collector and how does it optimize collections?

Accepted Answer

Go uses a concurrent, tri-color mark-and-sweep garbage collector. It runs concurrently with goroutines, minimizing 'Stop the World' (STW) pauses to sub-millisecond durations.

Question 24

How do you detect memory leaks and profile Go code using pprof?

Accepted Answer

Import `net/http/pprof` to expose profiling endpoints. Run load tests, capture heap profiles using `go tool pprof`, and inspect allocations to identify leaking memory.

Question 25

What is the difference between passing by value and passing by pointer in Go?

Accepted Answer

Passing by value copies parameter bytes onto the stack. Passing by pointer passes memory addresses, letting functions modify original values, but risking escaping allocations to the heap.

Question 26

How do you mock interfaces in Go testing?

Accepted Answer

Define mock structs implementing the target interface. In tests, pass the mock struct instance containing stubbed method variables to isolate your code from database or API services.

Question 27

Explain Go's init() function and its initialization order.

Accepted Answer

The `init()` function runs once per package at startup, after package variables are initialized. If multiple packages import each other, Go resolves imports in order, running `init` functions sequentially.

Question 28

Explain how to write custom middlewares in Go HTTP servers.

Accepted Answer

Write a function that takes a `http.Handler` and returns another handler. Intercept requests, execute middleware logic, and call the next handler's `ServeHTTP` method to pass execution.

Question 29

What is the difference between sync.WaitGroup and channels for synchronization?

Accepted Answer

- `sync.WaitGroup` is a simple counter used to wait for a set of goroutines to complete.
- Channels share data and coordinates tasks dynamically, which is more powerful for pipelining.

Question 30

How do you handle JSON serialization and deserialization in Go?

Accepted Answer

Use the `encoding/json` package. Define structs with JSON tags: `type User struct { Name string `json:"name"` }`. Marshal structs into JSON bytes or unmarshal bytes back into structs.

Question 31

Explain Go struct tags and how they are parsed using reflection.

Accepted Answer

Struct tags are string annotations attached to fields. Go modules (like JSON parsers or ORMs) parse these annotations at runtime using the `reflect` package to map fields to keys.

Question 32

How do you prevent goroutine leaks in Go applications?

Accepted Answer

Ensure that goroutines spawned to handle tasks (like reading channels) have exit conditions. If a channel is never closed or read, the goroutine blocks indefinitely, causing leaks.

Question 33

How do you write integration tests that access local Docker databases?

Accepted Answer

Use test libraries (like `testcontainers-go`) to spin up temporary database containers inside your test setup hooks, running migrations and tearing down resources after tests complete.

Golang Interview Questions for Freshers (2026)

What is Golang and Why is it Critical in Modern Engineering?

Golang Lifecycle Visualizer

Core Architectural Concepts in Golang

Goroutines Scheduler

Channels & Selectors

Strict Struct Interfaces

Memory Pointers Models

Garbage Collection Sweeper

check_circleWhy Modern Companies Choose Golang

lightbulbStrategic Preparation Tips

errorCrucial Mistakes to Avoid

trending_upHiring Trends & Career Outlook (2026)

Basics