Prepare for your intermediate Go interviews with these 100 carefully curated questions covering advanced topics in the Go programming language.

What are goroutines, and how do they differ from threads?h2

Goroutines are lightweight, user-space threads managed by the Go runtime, not the operating system. They enable concurrent execution of functions with minimal overhead, using a small initial stack (a few KB) that grows dynamically. Unlike OS threads, which are heavier (1-2 MB stack) and managed by the kernel, goroutines are multiplexed onto a smaller number of OS threads by Go’s scheduler, reducing resource usage and context-switching costs.

Key differences:

• Weight: Goroutines are lighter, allowing thousands to run efficiently, while threads are resource-intensive.
• Management: Goroutines are managed by Go’s runtime, threads by the OS.
• Concurrency: Goroutines simplify concurrent programming with channels and sync primitives, while threads often rely on locks.
• Creation: Starting a goroutine (e.g., go myFunc()) is faster and cheaper than creating a thread.

This makes goroutines ideal for scalable, high-concurrency applications.

How do you create a goroutine?h2

To create a goroutine in Go, prepend the go keyword to a function call. This launches the function to run concurrently in a lightweight, user-space thread managed by the Go runtime. For example:

func myFunction() {
    fmt.Println("Running in a goroutine")
}

func main() {
    go myFunction() // Start goroutine
    time.Sleep(time.Second) // Allow goroutine to run
}

The go keyword schedules myFunction to execute independently. Without time.Sleep or synchronization (e.g., channels or sync.WaitGroup), the main program might exit before the goroutine runs. Goroutines are cheap, with minimal stack overhead, and the Go scheduler multiplexes them onto OS threads for efficient concurrency. Use them for tasks like background processing or parallel computations, ensuring proper synchronization to avoid data races.

What is a channel in Go?h2

A channel in Go is a typed conduit for communication and synchronization between goroutines. It allows safe data exchange by ensuring only one goroutine reads or writes to the channel at a time, preventing data races. Channels are created using the make function, specifying the data type, e.g., ch := make(chan int).

Channels can be:

• Unbuffered: Block until both sender and receiver are ready (synchronous).
• Buffered: Allow sending up to a specified capacity without blocking (asynchronous).

Example:

ch := make(chan string) // Unbuffered channel
go func() { ch <- "Hello" }() // Send
msg := <-ch // Receive

Channels are used with the <- operator to send (ch <- value) or receive (value := <-ch). They’re essential for coordinating concurrent tasks, like passing results or signaling completion, without explicit locks.

How do you create a buffered channel?h2

To create a buffered channel in Go, use the make function with the chan keyword, specifying the channel’s data type and buffer capacity as the second argument. For example:

ch := make(chan int, 5) // Buffered channel with capacity 5

This creates a channel that can hold up to 5 integers before blocking. Sends to the channel (ch <- value) won’t block until the buffer is full, and receives (value := <-ch) won’t block until the buffer is empty. Here’s an example:

ch := make(chan string, 2)
ch <- "first"  // Non-blocking
ch <- "second" // Non-blocking
fmt.Println(<-ch) // Receive: first

Buffered channels are useful for asynchronous communication, allowing goroutines to send data without immediate synchronization, unlike unbuffered channels, which block until both sender and receiver are ready.

Explain the select statement in Go.h2

The select statement in Go is used to handle multiple channel operations concurrently, allowing a goroutine to wait on multiple channels and proceed with the first one that becomes ready. It resembles a switch statement but for channels, enabling non-blocking or prioritized communication.

Syntax:

select {
case <-ch1:
    // Handle receive from ch1
case ch2 <- data:
    // Handle send to ch2
default: // Optional
    // Execute if no channel is ready
}

Example:

ch1 := make(chan string)
ch2 := make(chan string)
select {
case msg := <-ch1:
    fmt.Println("Received from ch1:", msg)
case msg := <-ch2:
    fmt.Println("Received from ch2:", msg)
default:
    fmt.Println("No messages ready")
}

If multiple channels are ready, select chooses one randomly. The default case runs immediately if no channel is ready, preventing blocking. It’s ideal for multiplexing, timeouts, or coordinating multiple goroutines.

What is the sync package, and what are Mutexes?h2

The sync package in Go provides primitives for managing concurrency and synchronization between goroutines. It includes tools like Mutex, RWMutex, WaitGroup, Once, and Cond to coordinate shared resource access and execution.

A Mutex (mutual exclusion lock) is a synchronization primitive used to protect shared resources from concurrent access, preventing data races. It ensures only one goroutine can access a critical section at a time.

Example:

var mu sync.Mutex
var counter int

func increment() {
    mu.Lock()   // Acquire lock
    counter++   // Critical section
    mu.Unlock() // Release lock
}

func main() {
    go increment()
    go increment()
    time.Sleep(time.Second)
    fmt.Println(counter) // Safe access
}

Lock() blocks other goroutines from entering the critical section until Unlock() is called. Use Mutex for thread-safe operations on shared variables, but avoid overusing to prevent deadlocks or performance bottlenecks.

How do you use WaitGroups in Go?h2

A sync.WaitGroup in Go coordinates the completion of multiple goroutines, ensuring the main program waits for them to finish. It tracks a count of active goroutines and blocks until the count reaches zero.

Usage:

1. Declare a sync.WaitGroup.
2. Call Add(n) to set the number of goroutines to wait for.
3. Call Done() in each goroutine when it completes.
4. Call Wait() to block until all goroutines call Done().

Example:

var wg sync.WaitGroup

func worker(id int) {
    defer wg.Done() // Signal completion
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    wg.Add(2) // Wait for 2 goroutines
    go worker(1)
    go worker(2)
    wg.Wait() // Block until both finish
    fmt.Println("All workers done")
}

WaitGroup is ideal for ensuring all concurrent tasks complete before proceeding, avoiding premature program termination.

What is context in Go, and why is it used?h2

The context package in Go provides a way to manage cancellation, deadlines, and request-scoped values across goroutines. A Context carries deadlines, cancellation signals, and key-value pairs, enabling coordinated control in concurrent and distributed systems.

Key uses:

• Cancellation: Signal goroutines to stop, e.g., when a request is aborted.
• Deadlines/Timeouts: Set time limits for operations, like HTTP requests or database queries.
• Request-scoped values: Pass data (e.g., user IDs) across API boundaries.

Example:

func operation(ctx context.Context) error {
    select {
    case <-time.After(1 * time.Second): // Simulate work
        return nil
    case <-ctx.Done(): // Check for cancellation
        return ctx.Err()
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
    defer cancel()
    err := operation(ctx)
    fmt.Println(err) // Prints: context deadline exceeded
}

It’s used in APIs, HTTP servers, and database operations to ensure graceful termination, resource cleanup, and consistent request handling.

Explain interfaces in Go.h2

Interfaces in Go define a set of method signatures that a type must implement to satisfy the interface. They enable polymorphism without inheritance, allowing different types to share behavior. An interface is implicitly implemented by any type that provides the specified methods, without explicit declaration.

Syntax:

type MyInterface interface {
    Method1() string
    Method2(int) error
}

Example:

type MyInterface interface {
    Greet() string
}

type Person struct {
    Name string
}

func (p Person) Greet() string { // Person implicitly implements MyInterface
    return "Hello, " + p.Name
}

func main() {
    var i MyInterface = Person{Name: "Alice"}
    fmt.Println(i.Greet()) // Output: Hello, Alice
}

Key points:

• Implicit implementation: No need to declare a type implements an interface.
• Empty interface (interface{}): Accepts any type, used for generic-like behavior.
• Composition: Interfaces can embed other interfaces.
• Type safety: Ensures method compatibility at compile time.

Interfaces are central to Go’s flexibility, used in APIs like io.Reader and http.Handler.

How do you implement an interface?h2

In Go, implementing an interface is implicit. A type implements an interface by defining all the methods specified in the interface’s signature, without explicitly declaring the relationship. There’s no implements keyword—Go checks at compile time if the type’s methods match the interface.

Example:

type Speaker interface {
    Speak() string
}

type Person struct {
    Name string
}

func (p Person) Speak() string { // Person implicitly implements Speaker
    return "Hi, I'm " + p.Name
}

func main() {
    var s Speaker = Person{Name: "Alice"} // Assign Person to Speaker interface
    fmt.Println(s.Speak()) // Output: Hi, I'm Alice
}

Steps:

1. Define an interface with method signatures.
2. Create a type (e.g., struct) with methods matching the interface’s signatures.
3. Use the type as the interface type in assignments or function arguments.

This implicit approach promotes flexibility and loose coupling, widely used in Go’s standard library (e.g., io.Reader).

What is type assertion in Go?h2

Type assertion in Go extracts the underlying concrete type from an interface value. It’s used to access the specific type and its fields or methods when an interface holds a value of unknown type. The syntax is value.(Type), where value is an interface and Type is the expected concrete type.

Example:

var i interface{} = "hello"
s := i.(string) // Assert i is a string
fmt.Println(s) // Output: hello

If the assertion is incorrect, it causes a panic. To handle this safely, use the two-value form:

s, ok := i.(string)
if ok {
    fmt.Println("String:", s)
} else {
    fmt.Println("Not a string")
}

Type assertions are common when working with empty interfaces (interface{}) or when narrowing down interface types, like in JSON parsing or generic handlers, ensuring type-safe access to underlying data.

What is type switching?h2

Type switching in Go uses a switch statement with a type assertion to handle different concrete types stored in an interface value. It allows you to branch based on the underlying type of an interface, accessing type-specific fields or methods.

Syntax:

switch v := i.(type) {
case Type1:
    // Handle Type1
case Type2:
    // Handle Type2
default:
    // Handle unknown types
}

Example:

var i interface{} = "hello"
switch v := i.(type) {
case string:
    fmt.Println("String:", v)
case int:
    fmt.Println("Integer:", v)
default:
    fmt.Println("Unknown type")
}

Output: String: hello

Type switching is useful for handling dynamic types, such as in JSON parsing or when working with interface{} values. It avoids multiple type assertions, making code cleaner and safer by checking types at runtime without panicking.

Explain embedding in structs.h2

Embedding in Go structs allows one struct to include another struct or interface as an anonymous field, inheriting its fields and methods without explicit declaration. This promotes composition over inheritance, enabling code reuse and polymorphism.

Example:

type Person struct {
    Name string
}

func (p Person) Greet() string {
    return "Hello, " + p.Name
}

type Employee struct {
    Person // Embedded struct
    ID     int
}

func main() {
    e := Employee{Person: Person{Name: "Alice"}, ID: 123}
    fmt.Println(e.Name)      // Access embedded field directly
    fmt.Println(e.Greet())   // Call embedded method
}

Output: Alice, Hello, Alice

Key points:

• Embedded fields/methods are accessed directly (e.g., e.Name instead of e.Person.Name).
• Embedding an interface requires the struct to implement its methods.
• Conflicts in field/method names require explicit resolution.

Embedding is widely used in Go for modular, reusable code, like in io.ReadWriter.

How does error handling work with custom errors?h2

In Go, custom errors are created by implementing the error interface, which requires a single Error() string method. You define a custom error type, typically a struct, to encapsulate additional context or metadata.

Example:

type CustomError struct {
    Code int
    Msg  string
}

func (e *CustomError) Error() string {
    return fmt.Sprintf("Error %d: %s", e.Code, e.Msg)
}

func doSomething() error {
    return &CustomError{Code: 404, Msg: "Resource not found"}
}

func main() {
    err := doSomething()
    if err != nil {
        fmt.Println(err) // Output: Error 404: Resource not found
    }
}

Custom errors allow richer error information. Use type assertion or errors.As to inspect the custom error:

if ce, ok := err.(*CustomError); ok {
    fmt.Println(ce.Code) // Access Code
}

This approach enhances error handling with specific details while maintaining Go’s simplicity.

What is panic and recover in Go?h2

In Go, a panic is a runtime error that halts normal execution, unwinds the stack, and terminates the program unless handled. It’s used for unrecoverable errors, like out-of-bounds array access. A recover function retrieves a panic’s value, allowing graceful handling.

Example:

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered:", r)
        }
    }()
    panic("Critical error") // Triggers panic
    fmt.Println("This won't run")
}

Output: Recovered: Critical error

Key points:

• Panic: Call panic(value) to trigger, passing any value (e.g., string or error).
• Recover: Use recover() in a deferred function to capture the panic value and resume execution.
• Use sparingly for exceptional cases, not routine error handling. defer ensures recover runs during stack unwinding, preventing program crashes.

How do you use the testing package in Go?h2

The testing package in Go is used to write and run unit tests and benchmarks. Tests are written in files ending with _test.go and executed using go test.

Example:

package main

import "testing"

func Add(a, b int) int { return a + b }

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Add(2, 3) = %d; want 5", result)
    }
}

Key points:

• Test functions: Start with Test, take a *testing.T parameter, and use methods like t.Error or t.Fatal to report failures.
• Run tests: Use go test to execute all tests in a package.
• Assertions: Use t.Errorf for non-fatal errors, t.Fatalf to stop the test.
• Table-driven tests: Define test cases in a slice for multiple inputs.

The package supports parallel tests (t.Parallel), setup/teardown (TestMain), and verbose output (go test -v).

What is benchmarking in Go?h2

Benchmarking in Go measures the performance of code using the testing package. Benchmarks are written in files ending with _test.go and run with go test -bench=.. They use a *testing.B parameter and iterate code in a loop controlled by b.N.

Example:

package main

import "testing"

func Fib(n int) int {
    if n <= 1 {
        return n
    }
    return Fib(n-1) + Fib(n-2)
}

func BenchmarkFib(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Fib(10)
    }
}

Key points:

• Benchmark functions: Start with Benchmark, take *testing.B, and run the code b.N times.
• Execution: Use go test -bench=. to run benchmarks, reporting time per operation.
• Reset timers: Use b.ResetTimer() to exclude setup time.
• Profiling: Combine with -cpuprofile or -memprofile for deeper analysis.

Benchmarks help optimize code by identifying performance bottlenecks.

Explain the reflect package.h2

The reflect package in Go enables runtime inspection and manipulation of types and values. It’s used to examine the type, structure, and content of variables dynamically, especially when working with interfaces or unknown types.

Key features:

• Type inspection: reflect.TypeOf(v) returns the type of v.
• Value inspection: reflect.ValueOf(v) provides a Value for accessing fields, methods, or modifying values.
• Dynamic operations: Modify values, call methods, or inspect struct fields/tags.

Example:

type Person struct {
    Name string
}

func main() {
    p := Person{Name: "Alice"}
    t := reflect.TypeOf(p)  // Get type
    v := reflect.ValueOf(p) // Get value
    fmt.Println(t.Name())   // Output: Person
    fmt.Println(v.FieldByName("Name")) // Output: Alice
}

Use cases include serialization (e.g., JSON encoding), debugging, or generic code. However, it’s slower and less safe than static typing, so use sparingly for performance-critical code.

What are closures in Go?h2

Closures in Go are anonymous functions that capture and retain access to variables from their surrounding scope, even after the scope has exited. They combine a function with its lexical environment, allowing the function to access those variables later.

Example:

func outer(name string) func() string {
    return func() string { // Anonymous function
        return "Hello, " + name // Captures 'name'
    }
}

func main() {
    greet := outer("Alice") // Returns a closure
    fmt.Println(greet())    // Output: Hello, Alice
}

Key points:

• Variable capture: The inner function retains access to outer scope variables (e.g., name).
• Lifetime: Captured variables persist as long as the closure exists.
• Use cases: Common in callbacks, deferred execution, or maintaining state without globals (e.g., in HTTP handlers or iterators).

Closures provide a powerful way to encapsulate state and behavior, enhancing flexibility in concurrent or functional patterns.

How do you handle concurrency safely?h2

In Go, safe concurrency is achieved using goroutines and synchronization primitives to prevent data races and ensure thread-safe operations. Key techniques include:

• Channels: Use channels for safe data exchange between goroutines. Unbuffered channels synchronize communication, ensuring one goroutine sends while another receives.

  ch := make(chan int)
  go func() { ch <- 42 }()
  result := <-ch

• Mutexes: Use sync.Mutex to protect shared resources. Lock critical sections with Lock() and release with Unlock().

  var mu sync.Mutex
  var counter int
  mu.Lock()
  counter++
  mu.Unlock()

• WaitGroups: Use sync.WaitGroup to wait for goroutines to complete, avoiding premature program exit.

• Avoid shared state: Prefer passing data via channels over shared variables.

• Race detector: Run go test -race to detect data races.

These tools ensure safe, predictable concurrent execution without race conditions.

What is the race detector in Go?h2

The race detector in Go is a tool that identifies data races in concurrent programs. A data race occurs when two or more goroutines access the same variable simultaneously, with at least one performing a write, and no synchronization (e.g., mutexes or channels) is used. The race detector is built into the Go toolchain and enabled with the -race flag.

Usage:

go run -race main.go
go test -race

Example:

var counter int
func main() {
    go func() { counter++ }()
    go func() { counter++ }()
    time.Sleep(time.Second)
}

Running with -race detects the race condition and outputs a warning with stack traces, pinpointing unsynchronized accesses.

Key points:

• Detects races in shared variables, not all concurrency issues.
• Adds runtime overhead, so use in development/testing, not production.
• Helps ensure safe concurrency by identifying issues early.

Use it to debug and verify thread-safe code.

Explain the net/http package.h2

The net/http package in Go provides tools for building HTTP servers and clients. It simplifies handling HTTP requests, responses, routing, and middleware, making it a cornerstone for web development in Go.

Key components:

• HTTP Server: http.ListenAndServe starts a server, and http.Handler or http.HandlerFunc defines request handling.

  func handler(w http.ResponseWriter, r *http.Request) {
      fmt.Fprint(w, "Hello, World!")
  }
  func main() {
      http.HandleFunc("/", handler)
      http.ListenAndServe(":8080", nil)
  }

• Routing: http.ServeMux (default multiplexer) maps URL paths to handlers.
• Requests/Responses: http.Request contains request details (method, URL, headers); http.ResponseWriter sends responses.
• Client: http.Client makes HTTP requests (Get, Post, etc.).
• Middleware: Chain handlers to add functionality like logging or authentication.

It’s lightweight, performant, and integrates with Go’s concurrency model, ideal for building scalable web services. Use third-party frameworks like gorilla/mux for advanced routing.

How do you create a simple HTTP server in Go?h2

To create a simple HTTP server in Go using the net/http package, you define a handler function and start the server with http.ListenAndServe. Here’s an example:

package main

import (
    "fmt"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Hello, World!")
}

func main() {
    http.HandleFunc("/", handler) // Register handler for root path
    http.ListenAndServe(":8080", nil) // Start server on port 8080
}

Steps:

1. Import net/http.
2. Define a handler function with signature func(http.ResponseWriter, *http.Request).
3. Use http.HandleFunc to map a URL path (e.g., ”/”) to the handler.
4. Call http.ListenAndServe with a port (e.g., "<8080>") and a multiplexer (nil for default).

Access http://localhost:8080 in a browser to see “Hello, World!”. The server runs concurrently, handling requests in goroutines. Use http.ServeMux for custom routing or add middleware for extended functionality.

What are middleware in Go web development?h2

Middleware in Go web development is a function or handler that processes HTTP requests or responses before or after the main handler. It enables reusable logic for tasks like authentication, logging, or request modification, sitting between the server and the final handler.

Example:

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r) // Call next handler
        log.Printf("%s %s %s", r.Method, r.URL.Path, time.Since(start))
    })
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Hello!")
    })
    http.ListenAndServe(":8080", loggingMiddleware(mux))
}

Key points:

• Middleware takes a http.Handler and returns a new http.Handler.
• Chains multiple middleware using composition.
• Common uses: logging, authentication, CORS, or request validation.
• Integrates with net/http or frameworks like gorilla/mux.

This enhances modularity and reusability in web applications.

How do you parse JSON in Go?h2

In Go, JSON parsing is done using the encoding/json package with json.Unmarshal. It converts a JSON-encoded byte slice into a Go struct or map. Define a struct with fields matching the JSON keys, using tags to map names.

Example:

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    jsonData := []byte(`{"name":"Alice","age":25}`)
    var person Person
    err := json.Unmarshal(jsonData, &person)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Printf("Name: %s, Age: %d\n", person.Name, person.Age)
}

Output: Name: Alice, Age: 25

Key points:

• Use json.Unmarshal to parse JSON into a struct or map[string]interface{}.
• Struct tags (e.g., json:"name") map JSON keys to fields.
• Handle errors from json.Unmarshal for invalid JSON.
• Use pointers to modify the target struct.

What is the encoding/json package?h2

The encoding/json package in Go provides functions for encoding and decoding JSON data. It allows you to convert Go data structures (structs, maps, slices) to JSON (marshalling) and JSON data to Go structures (unmarshalling).

Key functions:

• json.Marshal(v interface{}) ([]byte, error): Converts a Go value to JSON bytes.
• json.Unmarshal(data []byte, v interface{}) error: Parses JSON bytes into a Go value.
• json.NewEncoder(w io.Writer) and json.NewDecoder(r io.Reader): Stream JSON encoding/decoding.

Example:

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    p := Person{Name: "Alice", Age: 25}
    data, _ := json.Marshal(p) // Encode to JSON
    fmt.Println(string(data))   // Output: {"name":"Alice","age":25}
}

Use struct tags (e.g., json:"name") to customize JSON field names. It’s essential for APIs, configuration files, and data serialization.

Explain database/sql package.h2

The database/sql package in Go provides a standard interface for interacting with SQL databases (or SQL-like systems) in a database-agnostic way. It abstracts database operations, allowing you to write portable code using drivers for specific databases (e.g., MySQL, PostgreSQL).

Key components:

• DB: sql.DB represents a database connection pool, managing connections for queries.
• Queries: Methods like Query, QueryRow, Exec perform SQL operations.
• Prepared Statements: Prepare creates reusable SQL statements for efficiency and security.
• Transactions: Begin, Commit, Rollback manage transactional operations.

Example:

package main

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
    "log"
)

func main() {
    db, err := sql.Open("mysql", "user:password@/dbname")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    rows, err := db.Query("SELECT name FROM users")
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()
    for rows.Next() {
        var name string
        rows.Scan(&name)
        log.Println(name)
    }
}

Key points:

• Import a database driver (e.g., go-sql-driver/mysql).
• Use sql.Open to initialize sql.DB.
• Methods like Scan extract query results into variables.
• Supports connection pooling, safe concurrency, and error handling.

It’s ideal for building scalable, database-driven applications while maintaining driver flexibility.

How do you connect to a database in Go?h2

To connect to a database in Go, use the database/sql package with a database driver (e.g., github.com/go-sql-driver/mysql for MySQL). Call sql.Open to create a sql.DB connection pool, passing the driver name and connection string.

Example (MySQL):

package main

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
    "log"
)

func main() {
    db, err := sql.Open("mysql", "user:password@tcp(localhost:3306)/dbname")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close() // Close when done

    // Verify connection
    err = db.Ping()
    if err != nil {
        log.Fatal(err)
    }
    log.Println("Connected to database")
}

Key points:

• Import the driver anonymously (_).
• Connection string format depends on the database (e.g., user:password@tcp(host:port)/dbname for MySQL).
• sql.DB manages a connection pool, safe for concurrent use.
• Use db.Ping() to confirm connectivity.
• Always defer db.Close() to release resources.

What is dependency management in Go, and what is Go Modules?h2

Dependency management in Go handles external packages and libraries a project relies on, ensuring consistent builds and versioning. Go Modules, introduced in Go 1.11, is the standard dependency management system, replacing tools like dep.

Go Modules:

• Uses a go.mod file to define the module’s name, Go version, and dependencies.
• Tracks dependency versions and ensures reproducible builds.
• Commands like go get add dependencies, updating go.mod and downloading packages.
• The go.sum file records cryptographic hashes for dependency integrity.

Example:

// Initialize a module
go mod init example.com/myapp

// Add a dependency
go get github.com/some/package

This creates go.mod:

module example.com/myapp
go 1.20
require github.com/some/package v1.2.3

Key points:

• go build or go run resolves dependencies automatically.
• Modules support versioning, vendoring, and reproducible builds.
• Use go mod tidy to clean up unused dependencies.

Explain vendoring in Go.h2

Vendoring in Go is the practice of storing a project’s dependencies locally within a vendor/ directory to ensure consistent builds, especially in environments with limited network access. It was common before Go Modules but is still supported for compatibility.

With Go Modules (post-Go 1.11), vendoring is optional. You can create a vendor/ directory using:

go mod vendor

This downloads all dependencies listed in go.mod into vendor/. To build or run using vendored dependencies:

go build -mod=vendor
go run -mod=vendor

Key points:

• Purpose: Ensures dependencies are locally available, avoiding external fetches.
• Use case: Useful for offline builds or legacy projects.
• Drawbacks: Increases repository size; less common with reliable module proxies.
• Go Modules: Prefer go.mod for dependency management, but vendoring is supported for specific needs.

Vendoring guarantees reproducible builds but is rarely needed with modern Go workflows.

What are build tags in Go?h2

Build tags in Go, also called build constraints, are special comments at the top of a Go file that control whether the file is included in a build based on conditions like operating system, architecture, or custom flags. They help manage platform-specific code or conditional compilation.

Syntax:

// +build tag1,tag2

Example:

// +build linux

package main

import "fmt"

func main() {
    fmt.Println("Running on Linux")
}

Another file:

// +build windows

package main

import "fmt"

func main() {
    fmt.Println("Running on Windows")
}

Run with:

go build -tags linux

Key points:

• Tags are specified with // +build, followed by comma-separated tags (e.g., linux, windows, amd64).
• Use !tag to exclude (e.g., // +build !windows).
• Combine with go build -tags "tag1 tag2".
• Common use: Platform-specific code, feature flags, or testing.

Build tags enable flexible, maintainable code for different environments or configurations.

How do you cross-compile Go programs?h2

Cross-compiling in Go builds a program for a different operating system or architecture than the host system. Go supports this natively by setting the GOOS (operating system) and GOARCH (architecture) environment variables during the build process.

Example (compile for Linux on Windows):

GOOS=linux GOARCH=amd64 go build -o myapp

Steps:

1. Set GOOS (e.g., linux, windows, darwin) and GOARCH (e.g., amd64, arm, arm64).
2. Run go build with the -o flag to specify the output binary name.
3. Ensure dependencies are compatible with the target platform.

Example:

package main

import "fmt"

func main() {
    fmt.Println("Hello, cross-compile!")
}

GOOS=windows GOARCH=amd64 go build -o myapp.exe

Key points:

• Run go env GOOS GOARCH to check supported platforms.
• No external tools required; Go’s toolchain handles it.
• Useful for deploying to servers, containers, or embedded devices.

This ensures binaries work on the target system without rebuilding.

What is the unsafe package, and when should you use it?h2

The unsafe package in Go provides low-level operations that bypass type safety and memory management, allowing direct memory manipulation and type conversions. It’s primarily used for performance-critical code or interfacing with C libraries.

Key features:

• Pointer arithmetic: unsafe.Pointer enables pointer manipulation, unlike standard Go pointers.
• Type conversions: Convert between incompatible types (e.g., int to *float64).
• Access struct fields: Get raw memory offsets using unsafe.Sizeof, unsafe.Alignof, or unsafe.Offsetof.

Example:

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    i := 42
    p := unsafe.Pointer(&i)
    fp := (*float64)(p) // Unsafe type conversion
    fmt.Println(*fp)    // Undefined behavior
}

When to use:

• Interfacing with C code via cgo.
• Optimizing performance in rare cases (e.g., low-level data structures).
• Accessing memory layouts for serialization.

Caution: Avoid unless necessary; it risks memory corruption, undefined behavior, and breaks Go’s safety guarantees. Use standard Go for most tasks.

How do you use atomic operations?h2

Atomic operations in Go, provided by the sync/atomic package, ensure thread-safe manipulation of variables without mutexes. They’re used for low-level, high-performance concurrency, typically for simple operations like counters or flags.

Example:

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

func main() {
    var counter int32
    var wg sync.WaitGroup
    wg.Add(2)

    go func() {
        atomic.AddInt32(&counter, 1) // Atomic increment
        wg.Done()
    }()
    go func() {
        atomic.AddInt32(&counter, 1)
        wg.Done()
    }()

    wg.Wait()
    fmt.Println(atomic.LoadInt32(&counter)) // Output: 2
}

Key functions:

• atomic.AddInt32/64: Increments or decrements a value atomically.
• atomic.LoadInt32/64: Safely reads a value.
• atomic.StoreInt32/64: Safely writes a value.
• atomic.CompareAndSwapInt32/64: Conditionally updates a value.

Use atomic operations for simple, lock-free concurrency (e.g., counters, flags) to avoid mutex overhead, but prefer channels or mutexes for complex synchronization.

What is the sync.Once type?h2

The sync.Once type in Go ensures a function is executed exactly once, even in concurrent environments with multiple goroutines. It’s useful for one-time initialization tasks, like setting up a singleton or initializing resources.

Example:

package main

import (
    "fmt"
    "sync"
)

var once sync.Once
var value int

func initialize() {
    value = 42
    fmt.Println("Initialized")
}

func main() {
    var wg sync.WaitGroup
    wg.Add(2)
    go func() {
        once.Do(initialize)
        wg.Done()
    }()
    go func() {
        once.Do(initialize)
        wg.Done()
    }()
    wg.Wait()
    fmt.Println("Value:", value)
}

Output: Initialized, Value: 42

Key points:

• once.Do(f) runs f only once; subsequent calls are ignored.
• Thread-safe, preventing race conditions during initialization.
• Ideal for lazy initialization or setup tasks like database connections.
• Non-reentrant; avoid recursive calls to once.Do.

Use sync.Once for efficient, safe, one-time execution in concurrent programs.

Explain sync.Map.h2

The sync.Map type in Go, part of the sync package, is a thread-safe map designed for concurrent access without explicit locking. Unlike a regular map with a sync.Mutex, sync.Map optimizes for high-read, low-write scenarios, using atomic operations and internal separation of read and write paths.

Key methods:

• Store(key, value): Sets a key-value pair.
• Load(key): Retrieves a value, returning the value and a boolean (ok).
• Delete(key): Removes a key.
• Range(f func(key, value interface{}) bool): Iterates over entries.

Example:

var m sync.Map

func main() {
    m.Store("key1", 42)
    if v, ok := m.Load("key1"); ok {
        fmt.Println(v) // Output: 42
    }
    m.Delete("key1")
}

Use sync.Map for high-concurrency scenarios with frequent reads and infrequent writes, like caching. Avoid for single-goroutine or lock-based needs, where a regular map with sync.Mutex is simpler.

How do you cancel goroutines with context?h2

In Go, you can cancel goroutines using the context package by passing a context.Context that signals cancellation. The context.WithCancel, context.WithTimeout, or context.WithDeadline functions create a cancellable context. Goroutines monitor the context’s Done() channel to stop execution when cancellation is triggered.

Example:

package main

import (
    "context"
    "fmt"
    "time"
)

func worker(ctx context.Context) {
    select {
    case <-time.After(2 * time.Second): // Simulate work
        fmt.Println("Worker completed")
    case <-ctx.Done(): // Check for cancellation
        fmt.Println("Worker cancelled:", ctx.Err())
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go worker(ctx)
    time.Sleep(1 * time.Second)
    cancel() // Signal cancellation
    time.Sleep(1 * time.Second) // Wait for worker to exit
}

Output: Worker cancelled: context canceled

Key points:

• Use ctx.Done() in a select to detect cancellation.
• Call cancel() to signal all goroutines using the context.
• Ensure cleanup (e.g., closing resources) when ctx.Done() is triggered.
• Useful for HTTP requests, timeouts, or user-initiated cancellations.

What is context.WithTimeout?h2

context.WithTimeout in Go creates a context.Context that automatically cancels after a specified duration, useful for setting deadlines on operations like HTTP requests or database queries. It’s a wrapper around context.WithCancel and time.AfterFunc to trigger cancellation when the timeout expires.

Example:

package main

import (
    "context"
    "fmt"
    "time"
)

func worker(ctx context.Context) {
    select {
    case <-time.After(2 * time.Second): // Simulate work
        fmt.Println("Work completed")
    case <-ctx.Done():
        fmt.Println("Timed out:", ctx.Err())
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel() // Ensure cleanup
    go worker(ctx)
    time.Sleep(3 * time.Second) // Wait for worker
}

Output: Timed out: context deadline exceeded

Key points:

• Returns a context and a cancel function.
• Cancels automatically after the specified duration.
• Use ctx.Done() to detect timeout in goroutines.
• Call cancel() early to release resources if done before timeout.

How do you propagate values with context?h2

In Go, you can propagate values with the context package using context.WithValue to attach key-value pairs to a context. These values are request-scoped and accessible to goroutines handling the same context, making it ideal for passing metadata like user IDs or request IDs across API boundaries.

Example:

package main

import (
    "context"
    "fmt"
)

func main() {
    type key string
    ctx := context.WithValue(context.Background(), key("userID"), "12345")

    go func(ctx context.Context) {
        userID, ok := ctx.Value(key("userID")).(string)
        if ok {
            fmt.Println("UserID:", userID) // Output: UserID: 12345
        }
    }(ctx)

    // Wait for goroutine
    time.Sleep(time.Second)
}

Key points:

• Use context.WithValue(parent, key, value) to create a new context with the value.
• Keys should be unexported types (e.g., struct{} or custom type) to avoid collisions.
• Access values with ctx.Value(key), using type assertion to retrieve the value.
• Avoid overuse; only store request-scoped data, not for passing function arguments.

What is the empty interface?h2

The empty interface in Go, written as interface{}, is an interface with no methods. Since any type satisfies an interface with zero requirements, interface{} can hold values of any type, making it useful for generic programming.

Example:

func printValue(v interface{}) {
    fmt.Println(v)
}

func main() {
    var i interface{}
    i = 42        // Holds an int
    printValue(i) // Output: 42
    i = "hello"   // Holds a string
    printValue(i) // Output: hello
}

Key points:

• Flexibility: Accepts any type, like a void pointer in C.
• Type assertion/switch: Use v.(type) or type switches to access the underlying type.
• Use cases: JSON parsing, generic functions, or collections of mixed types.
• Caution: Sacrifices type safety; overuse can lead to runtime errors.

Use interface{} sparingly, preferring specific interfaces or generics (Go 1.18+) for type safety.

How do you use interface{} for generics-like behavior?h2

In Go, interface{} enables generics-like behavior by allowing functions or data structures to handle values of any type, as it has no method requirements. However, it requires type assertions or type switches to access the underlying value, sacrificing type safety. Since Go 1.18, generics are preferred, but interface{} is still used in legacy code or for dynamic types.

Example:

func printAnything(v interface{}) {
    switch val := v.(type) {
    case string:
        fmt.Println("String:", val)
    case int:
        fmt.Println("Int:", val)
    default:
        fmt.Println("Unknown:", val)
    }
}

func main() {
    printAnything("hello") // Output: String: hello
    printAnything(42)     // Output: Int: 42
}

Key points:

• Use interface{} to store or pass any type (e.g., in slices, maps, or function arguments).
• Access values with type assertions (v.(string)) or type switches.
• Common in JSON parsing or flexible APIs.
• Drawbacks: Runtime type errors, less safe than generics.

Prefer generics for modern Go code when type constraints are known.

What are error wrappers?h2

Error wrappers in Go are custom error types that encapsulate an underlying error while adding additional context or metadata. They implement the error interface and typically wrap another error to provide more details, such as stack traces or specific error codes, while preserving the original error for inspection. This is commonly done using the errors package (since Go 1.13) or libraries like github.com/pkg/errors.

Example:

package main

import (
    "errors"
    "fmt"
)

type CustomError struct {
    msg string
    err error
}

func (e *CustomError) Error() string {
    return fmt.Sprintf("%s: %v", e.msg, e.err)
}

func doSomething() error {
    return &CustomError{msg: "failed operation", err: errors.New("database error")}
}

func main() {
    err := doSomething()
    fmt.Println(err) // Output: failed operation: database error
}

Key points:

• Use errors.Wrap (from pkg/errors) or custom structs to wrap errors.
• Enables richer error messages and context.
• Use with errors.Is and errors.As to check or extract wrapped errors.
• Enhances debugging without losing original error information.

How do you use errors.Is and errors.As?h2

In Go, errors.Is and errors.As (introduced in Go 1.13) inspect wrapped errors to check their type or extract values. They work with errors wrapped using fmt.Errorf with %w or libraries like pkg/errors.

• errors.Is: Checks if an error or any wrapped error matches a specific error value.

  err := fmt.Errorf("wrapped: %w", errors.New("target error"))
  if errors.Is(err, errors.New("target error")) {
      fmt.Println("Found target error")
  }

• errors.As: Extracts the first error in the chain that matches a target type into a variable.

  type CustomError struct{ msg string }
  func (e *CustomError) Error() string { return e.msg }
  
  err := fmt.Errorf("wrapped: %w", &CustomError{msg: "custom"})
  var ce *CustomError
  if errors.As(err, &ce) {
      fmt.Println("Custom error:", ce.msg) // Output: Custom error: custom
  }

Key points:

• Use errors.Is for comparing specific error values (e.g., io.EOF).
• Use errors.As to extract typed errors for further inspection.
• Both traverse the error chain, supporting wrapped errors.

What is table-driven testing?h2

Table-driven testing in Go is a pattern where test cases are defined in a slice or array of structs, each containing input data and expected outputs. This approach organizes multiple test scenarios in a table-like structure, making tests concise, maintainable, and easy to extend.

Example:

package main

import "testing"

func Add(a, b int) int { return a + b }

func TestAdd(t *testing.T) {
    tests := []struct {
        a, b, want int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
    }
    for _, tt := range tests {
        t.Run(fmt.Sprintf("%d+%d", tt.a, tt.b), func(t *testing.T) {
            if got := Add(tt.a, tt.b); got != tt.want {
                t.Errorf("Add(%d, %d) = %d; want %d", tt.a, tt.b, got, tt.want)
            }
        })
    }
}

Key points:

• Define test cases as structs with inputs and expected results.
• Loop through the table to run tests.
• Use t.Run for named subtests, improving readability and debugging.
• Ideal for testing functions with multiple input-output combinations.

How do you mock dependencies in tests?h2

In Go, mocking dependencies in tests is typically done by defining interfaces for dependencies, creating mock implementations, and injecting them into the code under test. This approach leverages Go’s implicit interface satisfaction for flexibility.

Example:

package main

import "testing"

// Dependency interface
type DataStore interface {
    Get(id int) string
}

// Mock implementation
type MockStore struct {
    data map[int]string
}

func (m *MockStore) Get(id int) string {
    return m.data[id]
}

// Function to test
func GetData(ds DataStore, id int) string {
    return ds.Get(id)
}

// Test with mock
func TestGetData(t *testing.T) {
    mock := &MockStore{data: map[int]string{1: "test"}}
    result := GetData(mock, 1)
    if result != "test" {
        t.Errorf("GetData = %s; want test", result)
    }
}

Key points:

• Define an interface for the dependency (e.g., DataStore).
• Create a mock struct implementing the interface with controlled behavior.
• Pass the mock to the function during testing.
• Use libraries like testify/mock for complex mocks.
• Ensures isolation and predictable test outcomes.

What is the httptest package?h2

The httptest package in Go provides utilities for testing HTTP servers and clients. It simplifies creating mock HTTP servers, generating test requests, and capturing responses, making it ideal for unit testing net/http-based code without network dependencies.

Key components:

• httptest.NewServer: Creates a test HTTP server with a given handler.
• httptest.NewRequest: Constructs an http.Request for testing.
• httptest.ResponseRecorder: Records the response from a handler for inspection.

Example:

package main

import (
    "net/http"
    "net/http/httptest"
    "testing"
)

func Handler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello"))
}

func TestHandler(t *testing.T) {
    req := httptest.NewRequest("GET", "/", nil)
    w := httptest.NewResponseRecorder()
    Handler(w, req)
    if w.Body.String() != "Hello" {
        t.Errorf("got %s, want Hello", w.Body.String())
    }
}

Key points:

• No real network calls, ensuring fast and reliable tests.
• Use ResponseRecorder to check status codes, headers, or body.
• Ideal for testing handlers, middleware, or API endpoints.

How do you test HTTP handlers?h2

In Go, you test HTTP handlers using the net/http/httptest package, which provides tools to simulate HTTP requests and capture responses without a real server. Use httptest.NewRequest to create test requests and httptest.ResponseRecorder to record handler responses for verification.

Example:

package main

import (
    "net/http"
    "net/http/httptest"
    "testing"
)

func MyHandler(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    w.Write([]byte("Hello, World!"))
}

func TestMyHandler(t *testing.T) {
    req := httptest.NewRequest("GET", "/test", nil)
    w := httptest.ResponseRecorder()
    MyHandler(w, req)

    if w.Code != http.StatusOK {
        t.Errorf("got status %d, want %d", w.Code, http.StatusOK)
    }
    if got := w.Body.String(); got != "Hello, World!" {
        t.Errorf("got body %s, want Hello, World!", got)
    }
}

Key points:

• Create a request with httptest.NewRequest(method, url, body).
• Use httptest.ResponseRecorder to capture status, headers, and body.
• Verify response details (e.g., w.Code, w.Body.String()).
• For complex routing, test with httptest.NewServer.
• Ensures isolated, repeatable tests without network dependencies.

Explain deep equality with reflect.DeepEqual.h2

In Go, reflect.DeepEqual is a function from the reflect package that compares two values for deep equality, checking if they are structurally identical, including nested fields, slices, maps, and other complex types. Unlike the == operator, which checks for reference equality or simple value comparison, DeepEqual recursively examines the entire structure of the values.

Example:

package main

import (
    "fmt"
    "reflect"
)

func main() {
    a := []int{1, 2, 3}
    b := []int{1, 2, 3}
    fmt.Println(reflect.DeepEqual(a, b)) // Output: true

    m1 := map[string]int{"x": 1}
    m2 := map[string]int{"x": 1}
    fmt.Println(reflect.DeepEqual(m1, m2)) // Output: true

    fmt.Println(reflect.DeepEqual([]int{1, 2}, []int{2, 1})) // Output: false
}

Key points:

• Compares slices, maps, structs, arrays, and nested types recursively.
• Handles nil values, pointers, and interfaces.
• Useful in tests to compare complex data structures.
• Caveats: Slow due to reflection; sensitive to unexported fields (ignored in structs) and pointer addresses.

Use reflect.DeepEqual in testing (e.g., with testing.T) or when comparing dynamic types, but avoid in performance-critical code.

What are function literals?h2

Function literals in Go are anonymous functions defined inline without a named identifier. They are used to create functions on the fly, often for short-lived tasks, closures, or passing as arguments. They have the same syntax as regular functions but lack a name and are typically assigned to variables or passed directly.

Example:

package main

import "fmt"

func main() {
    // Function literal assigned to a variable
    add := func(a, b int) int {
        return a + b
    }
    fmt.Println(add(2, 3)) // Output: 5

    // Function literal passed directly
    func(x int) {
        fmt.Println("Square:", x*x)
    }(4) // Output: Square: 16
}

Key points:

• Syntax: func(parameters) returnType { body }.
• Often used in goroutines, callbacks, or deferred execution.
• Enable closures by capturing surrounding variables.
• Useful for concise, one-off logic without declaring named functions.

Function literals enhance flexibility in functional programming patterns.

How do you capture variables in closures?h2

In Go, closures are created using function literals that capture variables from their surrounding scope. These variables are accessible within the closure even after the outer function returns, as the closure retains a reference to them. Captured variables are shared, so modifications affect the original variable across all closures referencing it.

Example:

package main

import "fmt"

func counter() func() int {
    count := 0 // Captured variable
    return func() int {
        count++ // Modifies shared variable
        return count
    }
}

func main() {
    c1 := counter()
    c2 := counter()
    fmt.Println(c1()) // Output: 1
    fmt.Println(c1()) // Output: 2
    fmt.Println(c2()) // Output: 1 (separate instance)
}

Key points:

• Variables are captured by reference, not value, so changes persist.
• Each closure instance (e.g., c1, c2) captures its own copy of variables from separate outer function calls.
• Common in iterators, callbacks, or stateful functions.
• Be cautious of unintended side effects due to shared state in concurrent code.

Use closures for stateful or context-dependent logic.

What is data race?h2

A data race in Go occurs when two or more goroutines access the same memory location concurrently, with at least one performing a write, and there’s no synchronization (e.g., mutexes or channels). This leads to unpredictable behavior, as the outcome depends on the goroutines’ execution order.

Example of a data race:

package main

import (
    "fmt"
    "time"
)

func main() {
    var counter int
    go func() { counter++ }()
    go func() { counter++ }()
    time.Sleep(time.Second)
    fmt.Println(counter) // Output: unpredictable (e.g., 1 or 2)
}

Key points:

• Data races cause undefined behavior, like corrupted data or crashes.
• Detect using the race detector: go run -race main.go.
• Prevent with synchronization:
  • Mutexes: Use sync.Mutex to lock shared resources.
  • Channels: Coordinate data access safely.
  • Atomic operations: Use sync/atomic for simple variables.
• Common in concurrent programs without proper coordination.

Avoid data races by ensuring synchronized access to shared variables.

How do you avoid data races?h2

To avoid data races in Go, where multiple goroutines access shared memory concurrently with at least one write, use synchronization mechanisms to ensure safe access. Here are key strategies:

1. Channels: Prefer channels for communication between goroutines, ensuring safe data transfer without shared memory.

   ch := make(chan int)
   go func() { ch <- 42 }()
   result := <-ch

2. Mutexes: Use sync.Mutex or sync.RWMutex to lock shared resources during access.

   var mu sync.Mutex
   var counter int
   mu.Lock()
   counter++
   mu.Unlock()

3. Atomic Operations: Use sync/atomic for simple, lock-free updates (e.g., counters).

   var counter int32
   atomic.AddInt32(&counter, 1)

4. Avoid Shared State: Pass data via channels or function arguments instead of sharing variables.

5. Race Detector: Run go test -race or go run -race to detect races during development.

These methods ensure predictable, thread-safe concurrent execution.

Explain HTTP routing with net/http.h2

HTTP routing in Go’s net/http package maps URL paths and HTTP methods to handler functions, determining how incoming requests are processed. The package provides a default multiplexer, http.ServeMux, to handle routing.

Key points:

• ServeMux: A request multiplexer that matches URL patterns to registered handlers.
• Registering routes: Use http.Handle or http.HandleFunc to map a path to a handler.
• Handlers: Functions implementing http.Handler or http.HandlerFunc process requests.

Example:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Hello, World!")
    })
    mux.HandleFunc("/user", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "User Page")
    })
    http.ListenAndServe(":8080", mux)
}