
When you receive a slice or map as an argument in Go, keep in mind that it's passed by reference. This means that if you store the reference, any modifications to the original slice or map outside your function will affect your stored data. To prevent this, create a copy before storing it.

## Example: Avoiding Side Effects

Here's how you could implement this with a LoadBalancer struct that stores server IPs. By copying the slice, we avoid any unintended modifications.

```go
type LoadBalancer struct {
    servers []string
}

func (lb *LoadBalancer) SetServers(servers []string) {
    lb.servers = make([]string, len(servers))
    copy(lb.servers, servers)
}

func main() {
    serverList := []string{"192.168.1.1", "192.168.1.2"}
    lb := LoadBalancer{}
    lb.SetServers(serverList)

    // Modify serverList without affecting lb's servers
    serverList[0] = "10.0.0.1"

    fmt.Println(lb.servers) // Output: ["192.168.1.1", "192.168.1.2"]
}
```

In this example, `SetServers` creates a copy of `servers` before storing it in `lb.servers`, ensuring that changes to `serverList` outside the `LoadBalancer` do not affect the stored IPs.

## Maps Work the Same Way

The same applies to maps, as they're also reference types. To prevent external modifications, create a new map and copy values:

```go
type LoadBalancer struct {
    config map[string]string
}

func (lb *LoadBalancer) SetConfig(config map[string]string) {
    lb.config = make(map[string]string, len(config))
    for key, value := range config {
        lb.config[key] = value
    }
}
```

By copying the `config` map, any changes to the original map won't affect the `LoadBalancer`'s stored configuration.

When storing slices or maps passed as arguments, copy them to maintain data integrity. This practice ensures your data remains stable, preventing unintended side effects from external modifications.


Prevent unintended side effects by copying slices and maps received as arguments to maintain data integrity in Go.

Safe Handling of Slices and Maps


In Go, verifying interface compliance at compile time is a simple but powerful practice. By enforcing that types implement specific interfaces before runtime, you prevent subtle errors and keep your codebase reliable.

## When to Verify Interface Compliance

Use compile-time checks for:
- **Exported types that need to implement an interface** as part of their API contract.
- **Groups of types** that all need to meet the same interface requirements, whether exported or unexported.
- **Critical cases where breaking an interface implementation** would impact the reliability of your application.

## Example: Good

Let's look at how to enforce compliance correctly.

Adding a compile-time check ensures Handler implements http.Handler. If it doesn't, this will throw a compilation error:

```go
type Handler struct {
    // ...
}

var _ http.Handler = (*Handler)(nil)

func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // ...
}
```

## Explanation

The line `var _ http.Handler = (*Handler)(nil)` will fail at compile time if `*Handler` ever stops implementing `http.Handler`. For pointer types (e.g., *Handler), slices, or maps, use nil as the zero value on the right side of the assignment. For struct types, use an empty struct {}.

Using compile-time checks for interface compliance makes your Go code more robust and predictable, saving you from runtime surprises and enforcing your API contracts.


Enforcing interface compliance at compile time ensures your types correctly implement required interfaces, reducing runtime surprises.

Compile-Time Interface Compliance Checks

When to Verify Interface Compliance

Example: Good

Explanation