Framework/Library	Description	Use Cases	ORM Support	Popularity (out of 5)
net/http	Part of the Go standard library, provides HTTP client and server implementations.	Building HTTP servers with minimal dependencies.	No (Use standalone ORMs like GORM, SQLBoiler, or Ent)	5
Gin	A HTTP web framework that features a Martini-like API but with better performance.	Rapid development of RESTful APIs and web applications with performance and efficiency.	No (Popular with GORM)	5
Echo	A high performance, extensible, minimalist Go web framework.	Creating high performance, extensible web applications and APIs with a focus on simplicity.	No (Commonly used with GORM)	4.5
Beego	An open-source, high-performance web framework for the Go programming language.	Full-stack applications with MVC architecture, ORM, caching, and more, with less boilerplate.	Yes (Built-in ORM)	4
Fiber	Inspired by Express.js, designed to ease things up for fast development with zero memory allocation and performance in mind.	Building fast and scalable web applications with a minimalistic approach similar to Express.js.	No (Frequently used with GORM)	4.5
Gorilla Mux	A powerful URL router and dispatcher for golang.	Handling complex routing scenarios in web applications.	No (Use standalone ORMs)	4
Chi	A lightweight, idiomatic and composable router for building Go HTTP services.	Building modular and composable web services with middleware support.	No (Use standalone ORMs)	4
Buffalo	Aims to make the life of a Go web developer easier.	Full-stack web development with integrated tools for frontend, migrations, and more.	Yes (Popular with Pop ORM, now maintained separately)	3.5
Gokit	A programming toolkit for building microservices in Go.	Building microservices with a focus on maintainability and robustness.	No (Designed for interoperability with any ORM)	3.5
Gqlgen	A GraphQL server library for Go that focuses on code generation.	Building GraphQL APIs with strong typing, code generation, and customizability.	No (Can integrate with any ORM)	4

General Go Interview Questions

What is a goroutine in Go?
- A goroutine is a lightweight thread managed by the Go runtime, used for executing functions concurrently. Unlike traditional threads, goroutines have low memory overhead. Start a goroutine using the go keyword.
```
go func() {
    fmt.Println("Inside goroutine")
}()
fmt.Println("Outside goroutine")
```
How do you manage package versions in Go?
- Go uses modules for package management, allowing you to track versions via the go.mod file. You can specify versions of dependencies required by your application.
```
go mod init example.com/mymodule
go get github.com/example/[email protected]
```
What is the difference between an array and a slice in Go?
- Arrays have a fixed size, while slices are dynamic. Slices are more flexible and commonly used because they can grow and shrink as needed.
```
var myArray [3]int
mySlice := make([]int, 0)
mySlice = append(mySlice, 1)
```

Explain the use of interfaces in Go.

Interfaces allow you to define behavior. Any type that implements the interface's methods can be used wherever the interface is accepted.

type Greeter interface {
    Greet() string
}
type Person struct {
    Name string
}
func (p Person) Greet() string {
    return "Hello, " + p.Name
}
func greetSomeone(g Greeter) {
    fmt.Println(g.Greet())
}

What are channels and how are they used?

Channels are used for communication between goroutines, acting as conduits for data transfer.

ch := make(chan int)
go func() {
    ch <- 1  // Sending data into channel
}()
val := <-ch // Receiving data from channel
fmt.Println(val)

How does Go handle memory management?

Go handles memory with an automatic garbage collector, which deallocates memory that is no longer in use, helping to avoid common memory leaks.

// Memory management is handled automatically; example shows dynamic slice allocation
slice := make([]int, 0)
for i := 0; i < 1000; i++ {
    slice = append(slice, i)
}

What is a map in Go?
- Maps are key-value stores used for fast lookup of data. Keys are unique.
```
myMap := make(map[string]int)
myMap["key"] = 42
fmt.Println(myMap["key"])
```

What are some ways to optimize performance in Go programs?

Use pprof for profiling, use goroutines for concurrency, and select efficient data structures.

// Example of using goroutines for concurrency
func process(data []int, result chan<- int) {
    sum := 0
    for _, num := range data {
        sum += num
    }
    result <- sum
}

Explain defer, panic, and recover in Go.

Use defer for cleanup, panic to handle unexpected errors, and recover to regain control after a panic.

func riskyFunction() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from:", r)
        }
    }()
    panic("something bad happened")
}

What is the zero value in Go, and why is it useful?
- The zero value is the default value of a variable when no initial value is provided. It ensures type safety and predictable behavior.
```
var i int    // 0
var f float64 // 0.0
var b bool   // false
var s string // ""
fmt.Println(i, f, b, s)
```

Go Backend Interview Questions

What is the difference between a pointer and a value receiver in methods?

Pointer receivers can modify the underlying data, while value receivers work with a copy.

type MyType struct {
    value int
}
func (m *MyType) Modify() {
    m.value = 10  // Modifies the receiver's data
}
func (m MyType) Display() {
    fmt.Println(m.value)
}

How do you handle errors in Go?

Return errors from functions and handle them explicitly in your code.

func mightFail() (int, error) {
    return 0, errors.New("failed")
}
result, err := mightFail()
if err != nil {
    log.Fatalf("Error: %v", err)
}
fmt.Println("Result:", result)

What is a channel and how can you prevent it from leaking?
- Ensure you close channels and properly synchronize goroutines to prevent leaks.
```
ch := make(chan int)
go func() {
    ch <- 1
    close(ch)
}()
for num := range ch {
    fmt.Println(num)
}
```

Explain how you would use middleware in a Go web server.

Middleware intercepts HTTP requests for logging, authentication, etc.

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Printf("Request received: %s", r.URL.Path)
        next.ServeHTTP(w, r)
    })
}
http.Handle("/", loggingMiddleware(http.HandlerFunc(myHandler)))

Describe how you would set up a connection to a SQL database in Go.
- Use the database/sql package with appropriate database drivers.
```
db, err := sql.Open("postgres", "connection_string_here")
if err != nil {
    log.Fatal(err)
}
defer db.Close()
```

What is context in Go, and how is it used?

Manage request-scoped values, cancellation signals, and deadlines.

func operation(ctx context.Context) error {
    select {
    case <-ctx.Done():
        return ctx.Err()
    case <-time.After(1 * time.Hour):
        // operation logic here
    }
    return nil
}

How do you implement rate limiting in Go?

Use the golang.org/x/time/rate package to control the rate of operations.

limiter := rate.NewLimiter(1, 5) // 1 request per second with a burst of 5
if limiter.Allow() {
    // process request
} else {
    // deny request
}

What are the benefits of using Go modules?
- Dependency management, reproducible builds, and elimination of GOPATH.
```
go mod init mymodule
go mod tidy
```
How does Go handle Unicode and how can you manipulate Unicode strings?
- Use the unicode and strings packages for Unicode support.
```
for _, rune := range "Hello, 世界" {
    fmt.Printf("%c ", rune)
}
```
How do you ensure that a Go application is concurrently safe?
- Use mutexes, atomic operations, and proper channel usage to manage shared resources.
```
var lock sync.Mutex
var count int
func increment() {
    lock.Lock()
    count++
    lock.Unlock()
}
```

1UC1F3R616/go_cheat_sheet.md

General Go Interview Questions

Go Backend Interview Questions