Structs and Interfaces

The API Design That Finally Clicked

Month three with Go. I was building a notification system that needed to send messages via email, SMS, and Slack. Coming from object-oriented languages, I initially tried to build a class hierarchy in my head:

Notifier (base class)
├── EmailNotifier
├── SMSNotifier
└── SlackNotifier

But Go has no inheritance. No classes. No extends. I spent two days fighting the language before discovering interfaces:

type Notifier interface {
    Send(message string) error
}

type EmailNotifier struct { /* ... */ }
func (e *EmailNotifier) Send(message string) error { /* ... */ }

type SMSNotifier struct { /* ... */ }
func (s *SMSNotifier) Send(message string) error { /* ... */ }

type SlackNotifier struct { /* ... */ }
func (s *SlackNotifier) Send(message string) error { /* ... */ }

// This just works!
func notify(n Notifier, msg string) {
    n.Send(msg)
}

No inheritance declarations. No implements keyword. If it has the method, it satisfies the interface. This implicit satisfaction changed how I design systems.

This article covers Go's approach: composition over inheritance, interfaces for behavior.

---

Structs: Organizing Data

Structs group related data together.

Basic Struct

type User struct {
    ID       int
    Name     string
    Email    string
    Age      int
    IsActive bool
}

Creating Struct Instances

// Zero value initialization
var user User
fmt.Println(user)
// {0  "" 0 false}

// Struct literal
user := User{
    ID:       1,
    Name:     "Alice",
    Email:    "[email protected]",
    Age:      30,
    IsActive: true,
}

// Short form (must match field order)
user := User{1, "Alice", "[email protected]", 30, true}

// Partial initialization (rest are zero values)
user := User{
    Name:  "Alice",
    Email: "[email protected]",
}
// ID=0, Age=0, IsActive=false

Accessing Fields

user := User{Name: "Alice", Age: 30}

fmt.Println(user.Name)  // Alice
user.Age = 31
fmt.Println(user.Age)   // 31

Pointers to Structs

user := &User{
    Name: "Alice",
    Age:  30,
}

// Go automatically dereferences
fmt.Println(user.Name)  // Alice (no need for user->Name)
user.Age = 31

This is equivalent but more common:

func NewUser(name, email string) *User {
    return &User{
        Name:  name,
        Email: email,
    }
}

user := NewUser("Alice", "[email protected]")

---

Anonymous Structs

Useful for temporary data:

// API response
response := struct {
    Status  string `json:"status"`
    Message string `json:"message"`
    Data    []int  `json:"data"`
}{
    Status:  "success",
    Message: "Data retrieved",
    Data:    []int{1, 2, 3},
}

// Table-driven tests
tests := []struct {
    name     string
    input    int
    expected int
}{
    {"zero", 0, 0},
    {"positive", 5, 25},
    {"negative", -3, 9},
}

for _, tt := range tests {
    result := square(tt.input)
    if result != tt.expected {
        t.Errorf("%s: got %d, want %d", tt.name, result, tt.expected)
    }
}

---

Struct Embedding (Composition)

Instead of inheritance, Go uses composition:

type Address struct {
    Street  string
    City    string
    Country string
}

type Person struct {
    Name    string
    Age     int
    Address Address  // Explicit field
}

// Usage
person := Person{
    Name: "Alice",
    Age:  30,
    Address: Address{
        Street:  "123 Main St",
        City:    "Boston",
        Country: "USA",
    },
}

fmt.Println(person.Address.City)  // Boston

Anonymous Embedding (Promoted Fields)

type Person struct {
    Name string
    Age  int
    Address  // Anonymous field (no name)
}

person := Person{
    Name: "Alice",
    Age:  30,
    Address: Address{
        Street: "123 Main St",
        City:   "Boston",
    },
}

// Fields are "promoted"
fmt.Println(person.City)  // Boston (no need for person.Address.City)

// But still accessible
fmt.Println(person.Address.City)  // Boston

Real example from my user service:

type BaseModel struct {
    ID        int
    CreatedAt time.Time
    UpdatedAt time.Time
}

type User struct {
    BaseModel  // Embedded
    Name       string
    Email      string
}

type Post struct {
    BaseModel  // Same base fields
    Title      string
    Content    string
    AuthorID   int
}

user := User{
    BaseModel: BaseModel{ID: 1, CreatedAt: time.Now()},
    Name:      "Alice",
    Email:     "[email protected]",
}

fmt.Println(user.ID)        // 1 (promoted)
fmt.Println(user.CreatedAt) // 2026-01-04...

---

Methods on Structs

We covered this briefly before, but let's go deeper:

type Rectangle struct {
    Width  float64
    Height float64
}

// Value receiver
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// Pointer receiver
func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

rect := Rectangle{Width: 10, Height: 5}
fmt.Println(rect.Area())  // 50

rect.Scale(2)
fmt.Println(rect.Area())  // 200

When to Use Pointer Receivers

1. Method modifies the receiver

2. Receiver is large (avoid copying)

3. Consistency (if one method needs pointer, use pointers for all)

From my code review checklist:

// Good: Consistent pointer receivers
type Cache struct {
    data map[string]interface{}
}

func (c *Cache) Get(key string) interface{} { /* ... */ }
func (c *Cache) Set(key string, val interface{}) { /* ... */ }
func (c *Cache) Delete(key string) { /* ... */ }

// Bad: Mixed receivers (confusing)
func (c Cache) Get(key string) interface{} { /* ... */ }    // Value
func (c *Cache) Set(key string, val interface{}) { /* ... */ }  // Pointer

---

Interfaces: Defining Behavior

Interfaces specify what types can do, not how they do it.

Interface Declaration

type Writer interface {
    Write(data []byte) (int, error)
}

type Reader interface {
    Read(data []byte) (int, error)
}

// Multiple methods
type ReadWriter interface {
    Read(data []byte) (int, error)
    Write(data []byte) (int, error)
}

Implementing Interfaces

No explicit declaration needed! If a type has the methods, it satisfies the interface.

type File struct {
    name string
}

func (f *File) Write(data []byte) (int, error) {
    fmt.Printf("Writing to %s: %s\n", f.name, string(data))
    return len(data), nil
}

// File automatically satisfies Writer interface!
var w Writer = &File{name: "log.txt"}
w.Write([]byte("Hello"))

This is duck typing at compile time. If it walks like a duck and quacks like a duck, it's a duck.

---

Interface Satisfaction Example

My notification system:

// Define interface
type Notifier interface {
    Send(message string) error
}

// Email implementation
type EmailNotifier struct {
    SMTPHost string
    From     string
}

func (e *EmailNotifier) Send(message string) error {
    fmt.Printf("Sending email from %s: %s\n", e.From, message)
    // Actual email sending logic
    return nil
}

// SMS implementation
type SMSNotifier struct {
    APIKey string
}

func (s *SMSNotifier) Send(message string) error {
    fmt.Printf("Sending SMS via API: %s\n", message)
    // Actual SMS sending logic
    return nil
}

// Slack implementation
type SlackNotifier struct {
    WebhookURL string
}

func (s *SlackNotifier) Send(message string) error {
    fmt.Printf("Sending Slack message: %s\n", message)
    // Actual Slack webhook logic
    return nil
}

// Function that works with ANY notifier
func sendAlert(n Notifier, msg string) error {
    return n.Send(msg)
}

// Usage
email := &EmailNotifier{From: "[email protected]"}
sms := &SMSNotifier{APIKey: "abc123"}
slack := &SlackNotifier{WebhookURL: "https://..."}

sendAlert(email, "Server down!")
sendAlert(sms, "Server down!")
sendAlert(slack, "Server down!")

All three types satisfy Notifier without explicitly declaring it!

---

Empty Interface

The empty interface interface{} has zero methods, so all types satisfy it:

var anything interface{}

anything = 42
anything = "hello"
anything = true
anything = []int{1, 2, 3}
anything = map[string]int{"a": 1}

Use case: When you truly don't know the type (like json.Unmarshal).

Modern Go (1.18+) uses any as an alias:

var anything any  // Same as interface{}

anything = 42
anything = "hello"

---

Type Assertions

Extract concrete value from interface:

var value interface{} = "hello"

// Type assertion
str := value.(string)
fmt.Println(str)  // hello

// Will panic if wrong type
// num := value.(int)  // Panic!

// Safe assertion with check
num, ok := value.(int)
if ok {
    fmt.Println("It's an int:", num)
} else {
    fmt.Println("Not an int")
}

Type Switches

Check multiple types:

func describe(value interface{}) {
    switch v := value.(type) {
    case int:
        fmt.Printf("Integer: %d\n", v)
    case string:
        fmt.Printf("String: %s\n", v)
    case bool:
        fmt.Printf("Boolean: %t\n", v)
    case []int:
        fmt.Printf("Slice of ints: %v\n", v)
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

describe(42)           // Integer: 42
describe("hello")      // String: hello
describe(true)         // Boolean: true
describe([]int{1, 2})  // Slice of ints: [1 2]

Real example from my API router:

func handleResponse(w http.ResponseWriter, data interface{}) {
    switch v := data.(type) {
    case string:
        w.Write([]byte(v))
    case []byte:
        w.Write(v)
    case error:
        http.Error(w, v.Error(), http.StatusInternalServerError)
    default:
        json.NewEncoder(w).Encode(v)
    }
}

---

Standard Library Interfaces

io.Reader and io.Writer

These are Go's most important interfaces:

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

Why they matter: The entire standard library uses them.

// All implement io.Reader:
var r io.Reader

r = os.Stdin
r = strings.NewReader("hello")
r = bytes.NewBuffer([]byte{})
r, _ = os.Open("file.txt")
r, _ = http.Get("https://example.com")

// All implement io.Writer:
var w io.Writer

w = os.Stdout
w = &bytes.Buffer{}
w, _ = os.Create("output.txt")

Real example - copy from any reader to any writer:

// Download file
resp, _ := http.Get("https://example.com/file.zip")
defer resp.Body.Close()

out, _ := os.Create("file.zip")
defer out.Close()

// Copy from HTTP response to file
io.Copy(out, resp.Body)  // Works with ANY Reader/Writer!

Stringer Interface

type Stringer interface {
    String() string
}

If a type implements String(), fmt.Printf uses it:

type User struct {
    Name  string
    Email string
}

func (u User) String() string {
    return fmt.Sprintf("%s <%s>", u.Name, u.Email)
}

user := User{Name: "Alice", Email: "[email protected]"}
fmt.Println(user)  // Alice <[email protected]>

---

Interface Embedding

Interfaces can embed other interfaces:

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

type Closer interface {
    Close() error
}

// Embed multiple interfaces
type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

// Same as:
type ReadWriteCloser interface {
    Read(p []byte) (n int, err error)
    Write(p []byte) (n int, err error)
    Close() error
}

---

Practical Example: Plugin System

From my application framework:

// Define plugin interface
type Plugin interface {
    Name() string
    Init() error
    Execute() error
    Shutdown() error
}

// Logger plugin
type LoggerPlugin struct {
    logFile *os.File
}

func (p *LoggerPlugin) Name() string { return "Logger" }

func (p *LoggerPlugin) Init() error {
    var err error
    p.logFile, err = os.Create("app.log")
    return err
}

func (p *LoggerPlugin) Execute() error {
    _, err := p.logFile.WriteString("Plugin running...\n")
    return err
}

func (p *LoggerPlugin) Shutdown() error {
    return p.logFile.Close()
}

// Metrics plugin
type MetricsPlugin struct {
    requests int
}

func (p *MetricsPlugin) Name() string { return "Metrics" }
func (p *MetricsPlugin) Init() error {
    p.requests = 0
    return nil
}

func (p *MetricsPlugin) Execute() error {
    p.requests++
    fmt.Printf("Total requests: %d\n", p.requests)
    return nil
}

func (p *MetricsPlugin) Shutdown() error {
    fmt.Println("Final count:", p.requests)
    return nil
}

// Application manages plugins
type Application struct {
    plugins []Plugin
}

func (app *Application) Register(p Plugin) {
    app.plugins = append(app.plugins, p)
}

func (app *Application) Start() error {
    for _, p := range app.plugins {
        if err := p.Init(); err != nil {
            return fmt.Errorf("plugin %s init failed: %w", p.Name(), err)
        }
    }
    
    for _, p := range app.plugins {
        if err := p.Execute(); err != nil {
            return fmt.Errorf("plugin %s execute failed: %w", p.Name(), err)
        }
    }
    
    return nil
}

func (app *Application) Stop() {
    for _, p := range app.plugins {
        p.Shutdown()
    }
}

// Usage
app := &Application{}
app.Register(&LoggerPlugin{})
app.Register(&MetricsPlugin{})

app.Start()
// Do work
app.Stop()

Add new plugins without modifying application code!

---

Struct Tags

Metadata for struct fields, used by reflection:

type User struct {
    ID        int    `json:"id" db:"user_id"`
    Name      string `json:"name" db:"user_name"`
    Email     string `json:"email" db:"email" validate:"required,email"`
    Password  string `json:"-" db:"password_hash"`  // - means omit
    CreatedAt time.Time `json:"created_at,omitempty" db:"created_at"`
}

JSON marshaling:

user := User{
    ID:    1,
    Name:  "Alice",
    Email: "[email protected]",
}

data, _ := json.Marshal(user)
fmt.Println(string(data))
// {"id":1,"name":"Alice","email":"[email protected]"}

---

Your Challenge

Build a shape calculator:

// Define Shape interface with Area() and Perimeter() methods

// Implement for:
// - Rectangle (width, height)
// - Circle (radius)
// - Triangle (a, b, c sides)

// Write a function that accepts any Shape and prints its area and perimeter

// Bonus: Add a String() method for nice formatting

---

Key Takeaways

1. Structs group data, methods add behavior

2. Composition over inheritance - embed structs

3. Interfaces define behavior - not data

4. Implicit satisfaction - no implements keyword

5. Empty interface accepts any type

6. Type assertions extract concrete values

7. io.Reader/Writer are foundational interfaces

8. Struct tags add metadata for libraries

---

What I Learned

The notification system taught me that interfaces are about behavior, not hierarchy:

• No inheritance forced better design

• Implicit satisfaction made code flexible

• Small interfaces (1-3 methods) are best

• Composition beat inheritance every time

Coming from Java/C++, no classes felt limiting. But interfaces + composition proved more powerful. I could swap implementations without touching calling code. Tests became trivial with mock implementations.

Go's "composition over inheritance" isn't a restriction - it's freedom.

---

Next: Error Handling in Go

In the next article, we'll dive into Go's explicit error handling: the error interface, wrapping errors, when to panic, and the production incident that taught me to handle errors properly.