** 11. What Is GOMAXPROCS?

In Go Programming Language, GOMAXPROCS controls the maximum number of CPU threads that can execute Go code simultaneously.

It determines how many OS threads can run goroutines in parallel.

Example

runtime.GOMAXPROCS(4)

Important Points

• Default value = number of CPU cores
• Controls parallelism, not concurrency
• Managed by the Go scheduler

Package Required

import "runtime"

Interview Insight

Common interview question:

“Difference between concurrency and parallelism?”

• Concurrency → multiple tasks managed together
• Parallelism → tasks executed simultaneously

** 12. What Is runtime.Gosched()?

runtime.Gosched() voluntarily yields the processor, allowing other goroutines to run.

Example

runtime.Gosched()

Purpose

• Improves goroutine scheduling
• Prevents CPU monopolization
• Helps cooperative multitasking

Example

package main

import (
    "fmt"
    "runtime"
)

func main() {

    go func() {
        fmt.Println("Goroutine")
    }()

    runtime.Gosched()

    fmt.Println("Main")
}

Interview Insight

Gosched() pauses the current goroutine temporarily without blocking the thread.

** 13. What Is a Ticker in Go?

A ticker repeatedly sends values to a channel at fixed intervals.

It is provided by the time package.

Example

ticker := time.NewTicker(time.Second)

Receiving Tick Events

for t := range ticker.C {
    fmt.Println(t)
}

Stopping Ticker

ticker.Stop()

Common Use Cases

• Periodic tasks
• Monitoring systems
• Scheduled background jobs

Interview Insight

Difference:

• Timer → executes once
• Ticker → executes repeatedly

* 14. What Is a select Block Without a default Case?

A select block without a default case blocks until one channel operation becomes ready.

Example

select {

case msg := <-ch:
    fmt.Println(msg)
}

Behavior

• Waits indefinitely for channel activity
• Synchronizes goroutines naturally

Important Point

If all channels are blocked:

• select also blocks

Interview Insight

Adding a default case makes select non-blocking.

*** 15. How Does Garbage Collection Work in Go?

Go uses an automatic garbage collector (GC) to free unused memory.

The GC identifies objects that are no longer reachable and removes them.

Go GC Features

• Automatic memory management
• Concurrent garbage collection
• Low pause times

GC Phases

Benefits

• Prevents manual memory management
• Reduces memory-related bugs
• Improves developer productivity

Interview Insight

Go uses:

Concurrent Mark-and-Sweep Garbage Collection

*** 16. What Is a Memory Leak?

A memory leak occurs when memory is allocated but never released or reused properly.

In Go, leaks usually happen because objects remain referenced and cannot be garbage collected.

Common Causes

• Goroutine leaks
• Unclosed channels
• Global references
• Large unused slices

Example

var data [][]byte

If unused data remains referenced, memory usage grows continuously.

Interview Insight

Go has garbage collection, but memory leaks are still possible.

*** 17. How Do You Prevent Memory Leaks?

Common Prevention Techniques

1. Close Resources Properly

defer file.Close()

2. Avoid Goroutine Leaks

Use:

• Context cancellation
• Proper channel handling

3. Remove Unused References

Allow garbage collector to reclaim memory.

4. Limit Slice Retention

Avoid holding large underlying arrays unnecessarily.

5. Use Profiling Tools

Go provides:

pprof

Interview Insight

Most Go memory leaks are caused by:

• Long-lived references
• Stuck goroutines

*** 18. How Do You Optimize Go Code Performance?

Common Optimization Strategies

1. Reduce Memory Allocations

Reuse objects when possible.

2. Use Buffered Channels

Minimize blocking overhead.

3. Avoid Unnecessary Goroutines

Too many goroutines increase scheduling cost.

4. Use Efficient Data Structures

Choose proper:

• Maps
• Slices
• Struct layouts

5. Benchmark Code

go test -bench=.

6. Profile Applications

Use:

pprof

7. Minimize Reflection

Reflection is slower than direct access.

Interview Insight

Performance optimization should always be:

• Measured
• Benchmarked
• Profile-driven

*** 19. Strategies to Reduce GC Overhead

Effective Strategies

1. Reduce Object Allocations

Fewer allocations reduce GC workload.

2. Reuse Objects

Use:

sync.Pool

3. Avoid Temporary Objects

Minimize short-lived allocations.

4. Use Value Types Carefully

Large heap allocations increase GC pressure.

5. Preallocate Slices

make([]int, 0, 1000)

6. Reduce Pointer Usage

More pointers increase GC scanning work.

Interview Insight

GC performance becomes critical in:

• High-throughput systems
• Low-latency applications

*** 20. Performance Implications of Large Structs

Large structs can negatively impact performance because copying them requires more memory and CPU time.

Problems with Large Structs

• Higher memory usage
• Slower copying
• Increased cache misses
• More GC pressure

Example

type LargeStruct struct {
    Data [10000]int
}

Passing this by value is expensive.

Better Approach

Use pointer receivers.

Example

func process(ls *LargeStruct) {
}

Optimization Tips

• Use pointer receivers
• Avoid unnecessary copies
• Keep structs compact

Interview Insight

Struct field ordering can improve memory alignment and cache efficiency.

21. Difference Between Stack and Heap Allocation in Go

Stack Allocation

• Memory is allocated inside the function call stack.
• Allocation and deallocation are very fast.
• Memory is automatically freed when the function returns.
• Used for small, short-lived variables.

Example

func add() int {
    x := 10
    y := 20
    return x + y
}

Here, x and y are usually stored on the stack.

Heap Allocation

• Memory is allocated in the heap area.
• Managed by Go Garbage Collector (GC).
• Slightly slower because GC needs to track it.
• Used when data must survive outside the function scope.

Example

func createUser() *User {
    u := User{Name: "Go"}
    return &u
}

u escapes the function, so it is allocated on the heap.

Key Differences

Interview Insight

Interviewers often ask:

• “How does Go decide stack vs heap?”
• “What causes heap allocation?”
• “How does heap allocation affect performance?”

The answer is: Go uses escape analysis.

22. What is Escape Analysis?

Definition

Escape analysis is a compiler optimization technique used by Go to determine whether a variable should be allocated on the stack or heap.

If a variable “escapes” the function scope, Go allocates it on the heap.

Example

func test() *int {
    x := 10
    return &x
}

Here, x escapes because its address is returned.

So Go allocates x on the heap.

Non-Escaping Example

func test() int {
    x := 10
    return x
}

x does not escape, so it stays on the stack.

Check Escape Analysis

Use:

go build -gcflags="-m"

Example output:

moved to heap: x

Why It Matters

• Heap allocations increase GC pressure.
• More heap usage can reduce performance.
• Reducing escaping variables improves efficiency.

Interview Tip

A common interview question:

“How can you reduce heap allocations in Go?”

Answer:

• Avoid returning pointers unnecessarily.
• Use value types when possible.
• Minimize closures capturing variables.
• Reuse objects using sync.Pool.

23. How Do You Optimize JSON Encoding/Decoding?

Common Optimization Techniques

1. Use Structs Instead of map[string]interface{}

Bad

var data map[string]interface{}
json.Unmarshal(b, &data)

Better

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

Structs are faster and type-safe.

2. Use jsoniter for High Performance

Standard library is good, but faster alternatives exist.

Example:

import jsoniter "github.com/json-iterator/go"

var json = jsoniter.ConfigCompatibleWithStandardLibrary

3. Reuse Buffers

var buf bytes.Buffer
json.NewEncoder(&buf).Encode(data)

Avoid repeated allocations.

4. Avoid Reflection Heavy Operations

Reflection is expensive.

Prefer:

• concrete structs
• typed fields
• known schemas

5. Use Streaming for Large JSON

decoder := json.NewDecoder(file)

Avoid loading huge JSON into memory.

6. Use omitempty

Name string `json:"name,omitempty"`

Reduces payload size.

Interview Insight

Interviewers may ask:

• Why is JSON slow?
• Why is reflection expensive?
• Difference between Marshal and Encoder?

Important point:
Go’s standard JSON package uses reflection internally.

24. What is the unsafe Package?

Definition

The unsafe package allows low-level memory manipulation in Go.

It bypasses Go’s type safety.

Common Uses

• Pointer conversion
• Memory optimization
• Interacting with C libraries
• High-performance systems programming

Example

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    x := 10
    p := unsafe.Pointer(&x)

    fmt.Println(*(*int)(p))
}

Important Components

Risks

• Breaks type safety
• Can cause memory corruption
• May break across Go versions
• Harder to maintain

Interview Insight

Important statement:

“Use unsafe only when absolutely necessary.”

Mostly used in:

• runtime
• serialization libraries
• high-performance systems

25. Difference Between map and struct

Struct

• Fixed fields
• Compile-time type safety
• Faster access
• Better memory efficiency

Example

type User struct {
    Name string
    Age  int
}

Map

• Dynamic key-value storage
• Flexible structure
• Slower than struct
• Uses hashing internally

Example

m := map[string]int{
    "age": 25,
}

Key Differences

When to Use

Use Struct When:

• Schema is known
• Performance matters
• Strong typing needed

Use Map When:

• Dynamic fields required
• Unknown keys
• Flexible JSON-like data

Interview Insight

Common question:

“Why are structs generally faster than maps?”

Answer:
Struct field access is direct memory access.
Map access requires hashing and bucket lookup.

26. What is a Nil Interface and Why is it Problematic?

Important Concept

An interface is nil only when:

• type = nil
• value = nil

Problem Example

type User struct{}

func main() {
    var u *User = nil
    var i interface{} = u

    fmt.Println(i == nil)
}

Output:

false

Why?

Because interface internally stores:

(type, value)

In this case:

(*User, nil)

Type exists, so interface is not nil.

Internal Representation

interface = {
    type
    data
}

Both must be nil for interface to be nil.

Why It Causes Bugs

This commonly causes:

• incorrect nil checks
• panic situations
• hidden runtime bugs

Proper Check

if i == nil {
    // true only if both type and value nil
}

Or use reflection carefully when needed.

Interview Insight

This is one of the most commonly asked tricky Go interview questions.

Interviewers check whether candidates understand:

• interface internals
• runtime representation
• typed nil behavior

27. Difference Between Value Receiver and Pointer Receiver

Value Receiver

Behavior

• Receives a copy of the struct.
• Original object is not modified.

Example

type User struct {
    Name string
}

func (u User) change() {
    u.Name = "Go"
}

Pointer Receiver

Behavior

• Receives pointer to original struct.
• Can modify original data.

Example

func (u *User) change() {
    u.Name = "Go"
}

Key Differences

When to Use Pointer Receiver

Use pointer receiver when:

• modifying struct
• large struct
• avoiding copies
• consistency required

Interview Insight

A very common question:

“Can methods with pointer receivers satisfy interfaces?”

Yes.

But method sets matter.

Rule

• Value can call both receiver types.
• Pointer can call both receiver types.
• Interface satisfaction depends on method set.

28. What is Deep Copy vs Shallow Copy in Go?

Shallow Copy

Definition

Copies only top-level structure.

Nested references still point to same memory.

Example

type User struct {
    Scores []int
}

u1 := User{
    Scores: []int{1,2,3},
}

u2 := u1
u2.Scores[0] = 100

Both objects change because slice references same array.

Deep Copy

Definition

Copies all nested data into new memory.

Objects become completely independent.

Example

u2 := User{
    Scores: make([]int, len(u1.Scores)),
}

copy(u2.Scores, u1.Scores)

Now modifying u2 does not affect u1.

Key Differences

Interview Insight

Go assignments are usually shallow copies.

Special care required for:

• slices
• maps
• pointers
• channels

29. Difference Between new and make

new

Purpose

Allocates memory and returns pointer.

Works with all types.

Example

p := new(int)

Equivalent:

var x int
p := &x

make

Purpose

Initializes built-in reference types.

Used only for:

• slice
• map
• channel

Example

m := make(map[string]int)
s := make([]int, 5)
c := make(chan int)

Key Differences

Important Interview Point

Wrong

m := new(map[string]int)

Map is still nil internally.

Correct

m := make(map[string]int)

Interview Insight

make is special because slices, maps, and channels require runtime initialization.

30. How Do Slices Internally Work?

Slice Structure

A slice internally contains:

pointer -> underlying array
length
capacity

Internal Representation

slice = {
    ptr
    len
    cap
}

Example

s := []int{1,2,3}

Internally:

ptr -> array
len = 3
cap = 3

Append Behavior

Example

s := []int{1,2,3}
s = append(s, 4)

If capacity is full:

1. New larger array allocated
2. Old elements copied
3. New element added

Important Concept

Slices are views over arrays.

Multiple slices can share same underlying array.

Example

a := []int{1,2,3,4}

b := a[:2]
c := a[:2]

b[0] = 100
fmt.Println(c[0])

Output:

100

Because both share same array.

Length vs Capacity

s := make([]int, 3, 5)

len = 3
cap = 5

Interview Insight

Very common questions:

• How does append work internally?
• When does reallocation happen?
• Why do slices sometimes affect each other?
• Difference between length and capacity?

O(1)

m["name"] = "Go"

map
 ├── bucket array
 │     ├── bucket 1
 │     ├── bucket 2
 │     └── ...

hash collision

incremental resizing

fatal error: concurrent map writes

x := 10

if true {
    x := 20
    fmt.Println(x)
}

fmt.Println(x)

20
10

file, err := os.Open("a.txt")

if err != nil {
    return err
}

if data, err := io.ReadAll(file); err != nil {
    return err
}

data, readErr := io.ReadAll(file)

data, err := io.ReadAll(file)

data, err := readFile()

if err != nil {
    return err
}

return err

return fmt.Errorf("failed to read file: %w", err)

data, _ := readFile()

failed to connect database
invalid user id

Error occurred!!!

if errors.Is(err, os.ErrNotExist) {
}

if err != nil {
    return err
}

type ValidationError struct {
    Field string
}

func (e ValidationError) Error() string {
    return "invalid field: " + e.Field
}

func validate(age int) error {
    if age < 18 {
        return ValidationError{
            Field: "age",
        }
    }

    return nil
}

err := validate(10)

if v, ok := err.(ValidationError); ok {
    fmt.Println(v.Field)
}

var v ValidationError

if errors.As(err, &v) {
    fmt.Println(v.Field)
}

type APIError struct {
    StatusCode int
    Message    string
}

user not found
payment failed

func (e APIError) Error() string {
    return e.Message
}

func main() {
    defer fmt.Println("world")

    fmt.Println("hello")
}

hello
world

file, _ := os.Open("a.txt")
defer file.Close()

mu.Lock()
defer mu.Unlock()

defer cleanup()

LIFO order

defer fmt.Println(1)
defer fmt.Println(2)
defer fmt.Println(3)

3
2
1

defer f()

x := 10

defer fmt.Println(x)

x = 20

10

func test() (x int) {
    defer func() {
        x++
    }()

    return 5
}

6

panic("something went wrong")

default:
    panic("unexpected state")

if db == nil {
    panic("database init failed")
}

return error

func worker() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered:", r)
        }
    }()

    panic("boom")
}

go func() {
    defer func() {
        if r := recover(); r != nil {
            log.Println("panic recovered:", r)
        }
    }()

    process()
}()

No

var ErrNotFound = errors.New("not found")

if err == ErrNotFound {
}

errors.Is(err, ErrNotFound)

io.EOF
os.ErrNotExist
context.Canceled

Go 1.13

if err != nil {
    return fmt.Errorf("failed to read config: %w", err)
}

if errors.Is(err, os.ErrNotExist) {
}

var pathErr *os.PathError

if errors.As(err, &pathErr) {
}

API Error
  └── DB Error
       └── Network Error