Boost Your Go/Golang Skills, One Article at a Time.

Confused by http.HandlerFunc? This post makes it click - Learn Go/Golang

Thu, 02 Mar 2023 00:00:00 +0000

When trying to use functions as Go http handlers, you will run into http.HandlerFunc from the net/http package.

If you’re not yet comfortable with Go’s type system and/or interfaces it can be a surprisingly difficult thing to wrap your head around. Several things can trip you up:

There are two similarly named http.Handle(r)Func functions/types that do different things.
Examples using http.HandlerFunc make it look like a function call, which it is not.
The way http.HandlerFunc implements the http.Handler interface.

In this article we’ll go over each of these difficulties and by the end you’ll - hopefully - have a solid understanding of http.HandlerFunc and can confidently use functions as handlers.

Dealing with large structs in (table) tests in Go/Golang

Thu, 07 Sep 2023 00:00:00 +0000

Working with a lot of large structs in tests can be a bit of a pain.

While this is an extreme example I made up so I could get a video, I have encountered (and written) similarly structured code in real life.

If we zoom in on one test, you get something like this:

t.Run("diff meta title and title, publishable", func(t *testing.T) {
	p := Post{
		Title:       "My smile is stuck",
		Description: "I cannot go back to your frownland",
		Content:     "My spirit is made up of the ocean",
		MetaTitle:   "SEO Optimized Title",
	}

	assertTrue(t, IsPublishable(p))
})

What makes this painful?

Should you use pointers to slices in Go/Golang?

Thu, 03 Aug 2023 00:00:00 +0000

If you’re unfamiliar with Go slices, it might look like a good idea to pass around a pointer instead of the “entire collection”.

s := []string{"👁", "👃", "👁"}
doSomething(&s)
andAgain(&s)

However, this has no real upsides.

By passing around a slice, you’re already passing around a pointer: A slice holds a pointer to an underlying array.

If you want to know more about how slices work and are constructed, check out my build your own slice series of articles.

No string interpolation in Go/Golang. Use these alternatives

Wed, 03 Jul 2024 00:00:00 +0000

Coming from other languages it can be surprising that Go does not support string interpolation.

What do I mean by string interpolation?

Well, take this snippet of PHP for example:

$x = 49;
$msg = "Hello world";
echo "The number is $x and the message is $msg";

When running the program PHP will evaluate the double quoted string and automatically replace the $x and $msg placeholders with the appropriate values. In the end, The number is 49 and the message is Hello world will be echoed.

Should you use a slice of pointers to structs in Go/Golang?

Sun, 20 Aug 2023 00:00:00 +0000

While writing Go, you might might run into the following situation: You want to collect the results of a function in a slice. However, the function returns a pointer.

You might then ask yourself:

What kind of slice should I use? A slice of values or a slice of pointers?

Let’s make this a bit more concrete.

Suppose the following Album struct and ProduceAlbum function exist:

type Album struct {
	Title  string
	Artist string
}

// ProduceAlbum produces a random album. The details
// don't really matter in this article, in real code this might
// do an expensive calculation or retrieve data from a database.
func ProduceAlbum() *Album {
	vol := rand.Intn(100) + 1
	return &Album{
		Title:  fmt.Sprintf("Groovy vol. %d", vol),
		Artist: "👨‍🎤",
	}
}

Every time ProduceAlbum is called, it returns a pointer to a randomly titled Album.

How to Parse a Time or Date using time.Parse in Go/Golang

Thu, 23 Nov 2023 00:00:00 +0000

Every Go developer trips up on it at some point: parsing a date or time. If you haven’t done it before, it can be a frustrating experience.

But.. you’re not alone. There are a lot of developers who share your frustration:

So why does this go so wrong for so often?

Dear HTTP service, how can I trust you not to break my heart?

Thu, 12 Mar 2026 00:00:00 +0000

When you send your most intimate data to an AI-platform, how do you know it’s not being shared with third parties? Or, how do you know it won’t be used to train the next generation of models?

More generally, how do you know that any web service will fulfill its social, contractual and legal obligations?

From the outside you might be able to see that an endpoint is using SSL, but you’ll have no guarantees what happens beyond that.

Writing Benchmarks: Performance testing in Go/Golang

Thu, 24 Oct 2024 00:00:00 +0000

A big part of programming is about making choices:

What data type do I use? A map, a slice, something more fancy?
Do I implement this using recursion or a loop?
Should I pass a value or a pointer?

How to determine the best choice?

One way is to measure performance using benchmarks.

Go has built-in support for benchmarking in the testing package.

In this article you’ll see how benchmarks are structured, what to keep in mind when writing them and how to execute them.

Avoid inaccurate tests: Use httptest when testing HTTP handlers in Go/Golang

Thu, 03 Oct 2024 00:00:00 +0000

In Go, testing HTTP handlers is more work than testing regular functions. Inputs must be wrapped in HTTP requests, and responses are written to http.ResponseWriter, rather than being returned directly.

To make matters worse, handlers expect server-side requests, while it’s easy to mistakenly construct client-side requests.

You’d almost give up on testing your handlers altogether.

Please don’t.

This article will discuss how we can use httptest to safely test HTTP handlers.

Sets in Go/Golang – Using Maps and Recommended Packages

Thu, 19 Sep 2024 00:00:00 +0000

Go doesn’t offer a native set type, and the standard library doesn’t provide one either. So, how do you create sets in Go?

You use a map.

First, we’ll explore how maps can be used to implement sets.

However, if your program relies heavily on sets, maps can quickly become tedious. That’s why, in the second part, we’ll introduce an open-source package that offers two convenient set implementations.

Finally, since these solutions only work with comparable types, we’ll wrap up by exploring how to handle non-comparable types in sets.

Devlog I: The foundations of a Go/Golang web application

Thu, 02 May 2024 00:00:00 +0000

Back in March I began working on a Go web application called Househunt. It’s goal is to be a non-trivial reference code base.

While progress has been slower than I wanted, most of the foundational components are in place. They might see little tweaks and bugfixes, but I don’t expect major changes at this moment.

In this devlog I’ll list the major components and notes I made along the way.

But first, a screenshot of how the project looks now:

Prevent sensitive data from leaking in Go/Golang

Thu, 28 Mar 2024 00:00:00 +0000

By default Go allows you to easily format, log or output values of most types.

For example, the following code prints the XYZ struct as a string.

main.go

package main

import (
	"fmt"
)

type MyData struct {
	Field string
}

func main() {
	d := MyData{
		Field: "Hello world!",
	}

	fmt.Println(d)
}

Usually this is a good thing, as it allows for easy debugging and/or formatting.

Maps of functions in Go (Golang)

Thu, 21 Mar 2024 00:00:00 +0000

Sometimes a declarative approach makes your code a lot clearer.

Take environment variable handling for example. Some environment variables might have widly different validation rules, while others share the same rules.

Organizing code like this using just if statements can be challenging. Ideally you’d just specify the enviroment variable’s name and the relevant rules

Now, there are great packages like spf13/viper and kelseyhightower/envconfig that use reflection and struct tags to provide a more declarative solution.

Documented Example Project: Go/Golang Web Application

Wed, 13 Mar 2024 00:00:00 +0000

You know the saying “a good example is worth a thousand blog posts”?

Well probably not, because I just made it up. But the point stands, source code can provide a great way to learn.

I remember when I started out in Go, that I looked for example repositories. I don’t think I ever found any.

Most public repositories fall into two categories:

Kubernetes, Docker or similar giant open source projects.
“Quick start” repositories that provide scaffolding for getting a project of the ground.

While both are interesting, this is usually not what you’re looking for. You want something similar to what you’re building.

Composable HTTP Handlers using generics in Go/Golang

Tue, 27 Feb 2024 00:00:00 +0000

Implementing HTTP handlers in Go can be a bit of a chore. Most handlers will have to:

Retrieve request data from parameters, body, headers etc.
Validate this data: The “shape” of the data is often validated as soon as possible.
Call out to business logic or a data store for further validation, processing and/or querying.
Format responses for successful requests.
Handle errors by sending different responses.

Even if you move this functionality to dedicated functions it will still get quite repetitive, handlers need to call those functions and deal with errors.

URL path parameters and variables in Go (Golang) 1.22 and later

Thu, 15 Feb 2024 00:00:00 +0000

When dealing with HTTP based API’s it’s common to pass data using URL path parameters (also called path variables). These parameters are part of the path segment of an URL. They are usually used to identify resources for API operations.

In all but the simplest web apps, API’s are defined using routes. Patterns which map requests to HTTP handlers.

As part of these routes, we may want to define path parameters:

Change JSON Time and Date format in Go/Golang

Thu, 25 Jan 2024 00:00:00 +0000

The JSON standard does not have a built in type for time, so time values are usually handled as strings. With strings, there’s always a choice that must be made: How to format these the time values?

In the time package the choice was made to format time.Time values as time.RFC3339Nano by default. A common and practical format:

{
  "timestamp": "2024-01-24T00:00:00Z"
}

But what if you want to use a different format? Say YYYY-DD-MM, 25 Jan 2024 or Unix timestamps?

How to Compare Time or Date in Go/Golang with example code

Thu, 18 Jan 2024 00:00:00 +0000

It’s tempting to think of time (and dates by extension) as an ever increasing number. While you’re developing in Go you might even try to compare two time.Time values using the comparison operators.

You will then find out that comparisons using >, <, <= or >= won’t compile:

invalid operation: t > u (operator > not defined on struct)

Comparisons using == and != will compile, but you should be careful, it probably doesn’t do what you intended to do!

Get the Current Time: The Monotonic Clock in Go/Golang

Thu, 11 Jan 2024 00:00:00 +0000

In the documentation of Go’s time package you will find the term “monotonic clock” roughly 30 times. However, you likely won’t ever work with it directly. So, what is it for and why should you care?

In the previous article, we looked at how time.Time values represent “time instants” on timelines using a time.Location reference.

When created using time.Now() a time.Time can also contain a different time representation: The monotonic clock reading.

Time and Location Explained in Go/Golang

Thu, 21 Dec 2023 00:00:00 +0000

Have you ever used time.Now() or ran a method like createdAt.Format(...)?

The time package is a staple in many Go programs, often used for core functionality, logging, or other metadata.

When diving into its documentation, you’ll find it’s thorough but focusses on niche topics like “Monotonic Clocks”. It doesn’t really provide beginners with a clear introduction to the package.

This might raise questions like:

What exactly is the “instant in time” mentioned in the docs?
How does time.Time “represent” such an instant?
Is a time.Location just another term for “time zone”?

This article aims to answer such questions and (hopefully!) provide you with a solid mental model of the time package.

Anonymous structs in Go (Golang): What, How and When

Thu, 16 Nov 2023 00:00:00 +0000

Have you run into an elaborate struct definition with a struct inside a struct? Or, has someone told you to “use an inline struct definition”?

If you’re not sure how to approach any of this, then you’re in the right place.

This article will discuss anonymous structs: what they are and when to consider using them.

What is an anonymous struct?

You probably know that you can define struct types using a type definition:

Type safe way to add a value to a Go/Golang context

Sun, 12 Nov 2023 00:00:00 +0000

Are you unsure how to pass trace IDs (or other request-scoped data) through your application stack? Or are your fingers sore from typing type assertions for context values?

You’re in the right place!

This article will show you how to store and retrieve values from contexts:

In a type safe way.
Without littering your code base with keys and type assertions.

But, let’s start at the beginning: how do you actually add a value to a context?

Should you store that value in a Go/Golang context?

Sun, 12 Nov 2023 00:00:00 +0000

You might find yourself needing to pass new data to a significant amount of functions in your code base. Maybe you need to add a new parameter to an API, or every request should generate an ID to track it.

In Go web apps it’s common to pass a context.Context to practically every function or method. When half of the the functions in your code base need to be modified to accept new data it can be tempting to just add it to context instead. The context is already being passed around after all…

Make, Literals and Re-slicing - Go/Golang slice fundamentals

Wed, 30 Aug 2023 00:00:00 +0000

In this series we’ve thus far seen only one way of creating slices: by slicing an existing array.

food:= [4]string{"🍔", "🍕", "🍏", "🍊"}
fruits := food[2:4]
fmt.Println(fruits) // prints [🍏 🍊]

Creating slices like this was useful to introduce and demonstrate the relationship between arrays and slices.

However, it would be a bit annoying if this was the only way to create a slice. We’d be forced to use two variables (one for the array, one for the slice) every time we need one.

Append and Copy - Go/Golang slice fundamentals

Tue, 18 Jul 2023 00:00:00 +0000

Did you know that append can turn broccoli into pizza?

main.go

package main

import "fmt"

func main() {
    // a is an array with 3 elements.
    a := [3]string{"🍔", "🌭", "🥦"}

    // fastfood is a slice into the first two elements of a.
    fastfood := a[0:2]
    
    // broccoli is a slice into the last element of a.
    broccoli := a[2:3]

    fmt.Println("before", broccoli)

    fastfood = append(fastfood, "🍕")

    fmt.Println("after", broccoli)
}

While delicious, this is a bit weird.

Arrays and slices - Go/Golang slice fundamentals

Mon, 26 Jun 2023 00:00:00 +0000

When it comes to slices you can get pretty far without knowing how the sausage is made. However, things can get weird once you start slicing and reslicing.

If you consider slices to be “some kind of dynamic array”, the following output might be surprising.

main.go

package main

import "fmt"

func main() {
    // create an array with 4 fruits.
    fruits := [4]string{"🍊", "🍏", "🍎", "🍐"}

    // citrus is a slice with only the orange.
    citrus := fruits[0:1]

    // replace the orange with a lemon in citrus.
    citrus[0] = "🍋"

    // now print the original fruits array.
    fmt.Println(fruits)
}

If citrus and fruits were two independent collections, this would have output [🍊 🍏 🍎 🍐].

Choosing between context.Background() and context.TODO() in Go/Golang

Fri, 14 Apr 2023 00:00:00 +0000

If you have used the context package in the standard library, you might have noticed that there are two constructors that create an empty context: context.Background() and context.TODO().

So which one should you use when you need a new context?

Let’s check the docs

First, context.Background():

Background returns a non-nil, empty Context. It is never canceled, has no values, and has no deadline. It is typically used by the main function, initialization, and tests, and as the top-level Context for incoming requests.

Context cancellation: Don't waste resources on aborted requests in Go/Golang

Thu, 23 Mar 2023 00:00:00 +0000

If you open your browser and load a web page, but press the “stop loading” or “X” button before it is fully loaded, the browser will abort any open requests.

But what happens if such a http request already reached your Go application and it is being served by a handler?

Well.. if you’re not explicitly supporting cancellation, the handler will happily continue executing until it is time to write a response to the client. Once enough data is written, the server will attempt to write that data to the underlying connection, which will fail with an error like this:

Boost Your Go/Golang Skills, One Article at a Time.

Confused by http.HandlerFunc? This post makes it click - Learn Go/Golang

Dealing with large structs in (table) tests in Go/Golang

Should you use pointers to slices in Go/Golang?

No string interpolation in Go/Golang. Use these alternatives

Should you use a slice of pointers to structs in Go/Golang?

How to Parse a Time or Date using time.Parse in Go/Golang

Dear HTTP service, how can I trust you not to break my heart?

Writing Benchmarks: Performance testing in Go/Golang

Avoid inaccurate tests: Use httptest when testing HTTP handlers in Go/Golang

Sets in Go/Golang – Using Maps and Recommended Packages

Devlog I: The foundations of a Go/Golang web application

Prevent sensitive data from leaking in Go/Golang

Maps of functions in Go (Golang)

Documented Example Project: Go/Golang Web Application

Composable HTTP Handlers using generics in Go/Golang

URL path parameters and variables in Go (Golang) 1.22 and later

Change JSON Time and Date format in Go/Golang

How to Compare Time or Date in Go/Golang with example code

Get the Current Time: The Monotonic Clock in Go/Golang

Time and Location Explained in Go/Golang

Anonymous structs in Go (Golang): What, How and When

What is an anonymous struct?

Type safe way to add a value to a Go/Golang context

Should you store *that value* in a Go/Golang context?

Make, Literals and Re-slicing - Go/Golang slice fundamentals

Append and Copy - Go/Golang slice fundamentals

Arrays and slices - Go/Golang slice fundamentals

Choosing between context.Background() and context.TODO() in Go/Golang

Let’s check the docs

Context cancellation: Don't waste resources on aborted requests in Go/Golang

Should you store that value in a Go/Golang context?