Forem: Hugo Oliveira

Understanding Interfaces in Go — The Complete Beginner’s Guide

Hugo Oliveira — Mon, 10 Nov 2025 04:11:04 +0000

One of the most misunderstood features for newcomers to Go is the interface.
But once you understand how they really work, you’ll realize that they are one of Go’s most powerful design tools.

Let’s explore what they are, how they work, and why Go’s approach is so unique.

What is an Interface?

In Go, an interface defines behavior, not data.

It’s simply a collection of method signatures — no implementation, no data fields.

Think of it as a contract:
If a type has all the methods that an interface declares, it implicitly implements that interface.

“If it walks like a duck and quacks like a duck, it’s a duck.”
That’s the Go philosophy.

Example:

type Mover interface {
    Move(int, int)
}

Any type that has a Move(int, int) method automatically implements Mover.
No implements keyword, no inheritance needed. Go keeps it simple.

Working Example

Let’s build something fun: a small game-like example using structs, methods, and interfaces.

Structs: Our data types

type Item struct {
    X int
    Y int
}

type Player struct {
    name string
    Item          // Embedded struct (composition)
    Keys []string // Keys collected by the player
}

Item represents a position in a 2D space,
and Player embeds an Item, gaining its fields and methods (composition instead of inheritance).

Adding Methods

We’ll give Item a Move method:

func (i *Item) Move(deltaX, deltaY int) {
    i.X += deltaX
    i.Y += deltaY
}

Notice the receiver:
(i *Item) means this method belongs to Item and can modify it (pointer receiver).

Now both Item and Player can move, since Player embeds Item.

Implementing the Interface

Remember our interface?

type Mover interface {
    Move(int, int)
}

Both *Item and *Player have a Move method.
Therefore, they automatically implement Mover.

Let’s use that to our advantage:

func moveAll(ms []Mover, dx, dy int) {
    for _, m := range ms {
        m.Move(dx, dy)
    }
}

Now moveAll can move anything that can “move” — whether it’s an Item, a Player, or any other type you create later.

i := Item{X: 1, Y: 2}
p := Player{name: "Hugo", Item: Item{X: 10, Y: 20}}

ms := []Mover{&i, &p}
moveAll(ms, 5, 5)
fmt.Printf("%+v\n%+v\n", i, p)

This is polymorphism in Go — simple, explicit, and fast.

Composition Over Inheritance

Go doesn’t have inheritance like Java or C#.
Instead, it promotes composition — combining small, focused types together.

When you embed one struct inside another, like this:

type Player struct {
    Item
}

You get field and method promotion:
Player now “has” all the fields and methods of Item.

This approach is cleaner, more flexible, and avoids complex class hierarchies.

Best Practices for Interfaces

Define interfaces where they’re used, not where they’re implemented.
Example: a Mover interface should live in the game logic package, not inside the Player struct package.
Keep interfaces small.
The Go standard library averages only 2 methods per interface.
Small interfaces are easier to implement and compose.

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

Don’t overdesign.
Avoid creating interfaces “just in case”. Start with concrete types, and extract interfaces later if patterns emerge.
Accept interfaces, return concrete types.
This makes your functions flexible but still predictable.

func Process(m Mover) { ... }     // flexible input
func NewPlayer() Player { ... }   // clear output

When to Use Interfaces

Use them when you need:

Polymorphism (different types, same behavior)
Mocks for testing
Abstraction between packages (reduce coupling)
Multiple implementations of a common behavior

Don’t use them when:

You only have one implementation
You don’t need to abstract the behavior
You’re just defining data, not behavior

Recap

Concept	Description
Interface	A set of method signatures that define behavior
Implicit implementation	If a type has all required methods, it automatically implements the interface
Polymorphism	Different types can be used interchangeably if they satisfy the same interface
Composition	Embedding structs to reuse behavior (Go’s alternative to inheritance)
Best practice	Keep interfaces small and define them where they’re used

Interfaces in Go are a perfect reflection of the language’s philosophy:
simple, explicit, and pragmatic.

They let you focus on what really matters — behavior — without the complexity of inheritance chains or abstract hierarchies.

Once you understand that interfaces are about what something can do, not what it is, you’ll start writing idiomatic Go code that feels natural and elegant.

Mastering JSON the Go Way

Hugo Oliveira — Tue, 21 Oct 2025 21:54:46 +0000

One of the things I love about Go is how practical it is when dealing with JSON.
No complicated setup. No magic. Just clear, predictable code.

The encoding/json package provides two main ways to work with JSON:

- In-memory (Marshal/Unmarshal)
- Stream-based (Encoder/Decoder)

Let’s break it down.

1. Marshal and Unmarshal — for small or simple data

These are the most common functions when your JSON fits comfortably in memory.

▶️ Go → JSON (Marshal)

You convert a Go struct, map, or slice into JSON.

type User struct {
    Name  string `json:"name"`
    Email string `json:"email"`
}

user := User{"Hugo", "hugo@example.com"}
data, err := json.Marshal(user)
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(data))

Output:

{"name":"Hugo","email":"hugo@example.com"}

Use Marshal when:

You already have a Go object in memory.
You want to send or save it as JSON (HTTP response, file, etc.).
The data is not too large (fits easily in memory).

◀️JSON → Go (Unmarshal)

You convert JSON bytes into a Go struct or map.

jsonData := []byte(`{"name":"Hugo","email":"hugo@example.com"}`)

var user User
err := json.Unmarshal(jsonData, &user)
if err != nil {
    log.Fatal(err)
}

fmt.Println(user.Name)  // Hugo

Use Unmarshal when:

You receive JSON as a string or from a file and want to turn it into a Go type.
The JSON is fully available in memory.

✅ Tip:
Always pass a pointer to the destination (&user), so Go can modify the variable.

2. Encoder and Decoder — for streams or large data

When working with large JSON files or network streams, loading everything into memory isn’t efficient.
That’s where Encoder and Decoder come in — they work with streams (io.Reader and io.Writer).

▶️Go → JSON stream (Encoder)
You write JSON directly to an output, like a file or HTTP response.

user := User{"Hugo", "hugo@example.com"}
file, _ := os.Create("user.json")
defer file.Close()

encoder := json.NewEncoder(file)
encoder.SetIndent("", "  ") // optional, for pretty-print
encoder.Encode(user)

Use Encoder when:

You want to write JSON directly to a file, socket, or HTTP response.
You want to avoid keeping the full JSON in memory.
You’re writing continuous data (e.g., logs, API responses).

◀️ JSON stream → Go (Decoder)

You read JSON progressively from an input, like a file or HTTP request body.

file, _ := os.Open("user.json")
defer file.Close()

var user User
decoder := json.NewDecoder(file)
decoder.Decode(&user)

fmt.Println(user)

Use Decoder when:

You’re reading large JSON data.
The data is coming from a network or file stream.
You don’t want to load everything at once into memory.

Summary

Direction	Data Type	Function	Best for
JSON → Go	`[]byte`	`Unmarshal`	Small data in memory
Go → JSON	`[]byte`	`Marshal`	Small data in memory
JSON → Go	`io.Reader`	`Decoder`	Large files or streams
Go → JSON	`io.Writer`	`Encoder`	Large files or streams

Go’s encoding/json package is a perfect example of the language’s philosophy:
simple, explicit, and reliable.

When you need something quick and small, use Marshal and Unmarshal.
When you’re dealing with streams, files, or large payloads, use Encoder and Decoder.

You get both simplicity and performance, and you always know exactly what your code is doing.

That’s Go.

Understanding Strings in Go: Bytes, Runes, and the Truth Behind len

Hugo Oliveira — Mon, 20 Oct 2025 01:30:01 +0000

When you first start working with Go, strings might seem simple — until you try to count characters, index them, or work with emojis. Then you realize that Go treats strings in a way that’s both elegant and slightly tricky.

Let’s clear the confusion once and for all.

💡 What a string really is

In Go, a string is an immutable sequence of bytes, not a list of characters.

Internally, it’s represented roughly like this:

type stringStruct struct {
    Data *byte
    Len  int
}

Every byte is part of a UTF-8–encoded value. This means that characters like á or 🚀 may use multiple bytes.

📏 len() counts bytes, not characters

This one surprises a lot of newcomers. The len() function returns the number of bytes, not the number of visible characters.

s := "Olá"
fmt.Println(len(s)) // 4

Looks like three letters, right?
But “á” uses two bytes in UTF-8 (0xC3 0xA1).

🧩 Accessing by index (s[i])

When you index a string like s[i], you get a single byte (uint8), not a character.

s := "Olá"
fmt.Println(s[2]) // 195 (0xC3)

Here you’re only seeing part of the letter “á”.
Strings in Go are sequences of bytes, not runes.

🔁 Iterating with for

There are two main ways to loop over strings in Go — and they behave very differently.

1. Byte by byte

s := "Olá"
for i := 0; i < len(s); i++ {
    fmt.Printf("%d: %x\n", i, s[i])
}

Output:

0: 4f
1: 6c
2: c3
3: a1

Each byte of “á” is printed separately (c3 and a1).

2. Rune by rune

s := "Olá"
for i, r := range s {
    fmt.Printf("%d: %c (%[2]U)\n", i, r)
}

Output:

0: O (U+004F)
1: l (U+006C)
2: á (U+00E1)

Now Go decodes UTF-8 correctly and gives you full Unicode characters.

⚙️ byte vs rune

Type	Size	Meaning	Example
`byte`	1 byte (`uint8`)	Raw UTF-8 data	`'a' = 97`
`rune`	4 bytes (`int32`)	A full Unicode character	`'á' = 225`, `'🚀' = 128640`

You can convert between them:

s := "🚀"
b := []byte(s)
r := []rune(s)

fmt.Println(len(b)) // 4 bytes
fmt.Println(len(r)) // 1 rune

🧠 Choosing the right type

Use case	Recommended type	Why
File IO or network data	`[]byte`	Performance and control
Counting or printing characters	`[]rune` or `for range`	Handles Unicode properly
Storing text	`string`	Simple, safe, and immutable

🧭 Quick summary

Operation	Returns	Interprets as
`len(string)`	`int`	Number of bytes
`string[i]`	`uint8`	Byte value
`for range string`	`int32`	Unicode character
`[]byte(string)`	Slice of bytes	UTF-8 encoded
`[]rune(string)`	Slice of runes	Unicode code points

💬 Final thoughts

Go treats strings as byte sequences for a reason. It keeps things fast, memory-safe, and predictable.
But once you understand the difference between bytes and runes, you unlock the full power of Go’s simplicity.

Next time you work with text in Go, remember:
len() doesn’t count letters. It counts bytes.
And that tiny detail makes all the difference.

Why Choose Go for Development?

Hugo Oliveira — Mon, 20 Oct 2025 01:00:16 +0000

When I first discovered Go, it instantly felt different. It wasn’t trying to be clever or overloaded with features. It was clean, fast, and built with a purpose.

Go was created at Google in 2007 by Robert Griesemer, Rob Pike, and Ken Thompson. They wanted a language that combined Python’s simplicity with C’s performance and reliability. Something that made sense for building real-world, large-scale systems.

Today, Go stands out as one of the most pragmatic and enjoyable languages to work with. It is minimal, opinionated, and focused on what actually matters: clarity and performance.

⚙️ A language that helps you build better

Go makes you a better developer because it forces you to think clearly. It doesn’t hide complexity behind abstractions. Instead, it gives you the right tools to write code that is easy to understand, test, and maintain.

Some of the things that make Go so good:

Static Types that catch mistakes before they reach production
Garbage Collector that handles memory efficiently
Rich Standard Library with everything you need out of the box
Fast Compilation that keeps your feedback loop short
Explicit Error Handling that makes you deal with problems, not ignore them
Native Concurrency with goroutines and channels that just work
Cross-compilation to build for any OS easily
Built-in Tooling like go fmt, go test, and go mod that keep your workflow clean
Simplicity that encourages readable, maintainable, and long-lasting code

🚀 A community and ecosystem that inspire

Go powers some of the biggest tools in modern development. Docker, Kubernetes, Grafana, Prometheus, and Cloudflare all rely on it.

The community is one of the most welcoming and practical I have seen. It is full of developers who care about writing clean, maintainable software. Every library or project you find reflects that same spirit of simplicity and reliability.

💡 Final thoughts

Go is not just another programming language. It is a mindset. It is about doing more with less. It is about choosing simplicity over cleverness and clarity over chaos.

For me, Go represents what modern software development should feel like: fast, predictable, and deeply satisfying.

If you care about building systems that scale, perform, and stay maintainable over time, Go is a language that will make you fall in love with development again.