0 Comments

Basic Concepts

1. What are Goroutines and how are they different from threads?

Goroutines are lightweight threads of execution in Go. Unlike traditional OS threads, they are managed by the Go runtime rather than the operating system. Key differences include:

  • Goroutines start with a smaller stack size (2KB), which can grow as needed
  • They have faster startup times and lower memory overhead
  • The Go runtime multiplexes goroutines onto OS threads automatically
  • Communication between goroutines is handled through channels
  • They’re much more scalable (you can run thousands or even millions of goroutines)

2. What are channels and how do they work?

Channels are typed conduits that allow goroutines to communicate and synchronize their execution. They implement Go’s “share memory by communicating” philosophy instead of traditional shared memory concurrency.

Key points about channels:

  • They can be buffered or unbuffered
  • Sending on a nil channel blocks forever
  • Closing a closed channel causes a panic
  • Receiving from a closed channel returns the zero value immediately

3. What is the difference between buffered and unbuffered channels?

Unbuffered channels:

  • Synchronous (blocking)
  • Send operation blocks until receiver is ready
  • Receive operation blocks until sender sends data

Buffered channels:

  • Asynchronous up to buffer size
  • Send operation blocks only when buffer is full
  • Receive operation blocks only when buffer is empty

Memory Management

4. How does garbage collection work in Go?

Go uses a concurrent mark-and-sweep garbage collector with the following characteristics:

  • Tri-color mark-and-sweep algorithm
  • Concurrent execution with application code
  • Stop-the-world phases are very short
  • Write barriers to track heap modifications
  • Pacing algorithm to adjust GC frequency

The collector runs in these phases:

  1. Mark setup (STW)
  2. Marking (Concurrent)
  3. Mark termination (STW)
  4. Sweep (Concurrent)

5. What are defer statements and how do they work?

Defer statements delay the execution of a function until the surrounding function returns. They are commonly used for cleanup operations.

Key characteristics:

  • Deferred functions are executed in LIFO order
  • Arguments are evaluated when defer is called, not when the function executes
  • Deferred functions can read and modify named return values

Error Handling

6. How does error handling work in Go?

Go handles errors through explicit error values rather than exceptions.

7. What is panic and recover?

Panic is a built-in function that stops normal execution flow and begins panicking. Recover is a built-in function that regains control of a panicking goroutine.

Interfaces and Types

8. How do interfaces work in Go?

Interfaces in Go provide a way to specify the behavior of an object. They are implemented implicitly – any type that implements all methods of an interface automatically implements that interface.

Key points:

  • Interface satisfaction is implicit
  • Interfaces can be composed of other interfaces
  • Empty interface (interface{}) can hold values of any type
  • Type assertions are used to access underlying types

9. What are slices and how do they differ from arrays?

Slices are dynamic, flexible views into arrays. Unlike arrays, they are reference types and their size can change.

Key differences:

  • Arrays have fixed size, slices can grow
  • Arrays are values, slices are references
  • Passing an array creates a copy, passing a slice passes a reference
  • Slices have capacity in addition to length

Advanced Topics

10. What is the context package used for?

The context package provides a way to carry deadlines, cancellation signals, and request-scoped values across API boundaries and between processes.

Common uses:

  • Cancellation of long-running operations
  • Passing request-scoped values
  • Implementing timeouts
  • Controlling concurrent operations

11. What are the init() functions?

The init() function is called after all variable declarations in the package have evaluated their initializers, and those are evaluated only after all imported packages have been initialized.

Key points:

  • Multiple init() functions can exist in the same package
  • They execute in the order they appear in the source file
  • They cannot be referenced directly
  • They run before main()

Best Practices

13. What are some Go code style conventions?

Go emphasizes clean, readable code with consistent formatting. Key conventions include:

  • Use gofmt for formatting
  • Follow naming conventions (CamelCase for exported, camelCase for internal)
  • Keep functions small and focused
  • Use meaningful variable names
  • Document public APIs
  • Follow the “Accept interfaces, return structs” principle