Go on Bill Glover

Use the Kubernetes downwards API to set GOMEMLIMIT

hello@bill.dev (Bill) — Wed, 14 Sep 2022 21:10:06 +0100

Go 1.19 introduced the ability to tune the way the garbage collector works by setting a soft memory limit. One recommendation is to use this new memory limit when deploying in a container environment. This post looks at using the Kubernetes Downward API to set this soft limit.

Do I need a Soft Memory Limit

Do take advantage of the memory limit when the execution environment of your Go program is entirely within your control, and the Go program is the only program with access to some set of resources (i.e. some kind of memory reservation, like a container memory limit).

A good example is the deployment of a web service into containers with a fixed amount of available memory.

Use a forked Go module

hello@bill.dev (Bill) — Wed, 01 Jun 2022 11:19:16 +0100

Whenever I want to work with a forked Go module, I have to look up how to do so. It doesn’t feel immediately obvious what to change. This note documents my current approach.

I need to do this when a third party module I depend on doesn’t include features I need. I fork the third party module and make some changes. But these changes are only available in my fork. These may get merged into a new version of the module but in the meantime I want to continue working off my fork.

Build Multi-Architecture Docker Images

hello@bill.dev (Bill) — Fri, 01 Apr 2022 19:22:32 +0000

Back in 2018, I wrote about Multi-Architecture Docker Builds. My main aim then was to run the occasional container image on a Raspberry Pi. Apple’s transition to M1 based machines has increased demand for multi-architecture container images. In this post, I document an improved approach to building multi-architecture images.

I’ll use a Go application to show the build process. It prints the current runtime OS and CPU architecture to the terminal and then exits.

Go on ARM: why struct field alignment matters

hello@bill.dev (Bill) — Fri, 19 Jun 2020 14:00:00 +0000

I’d assumed the Go compiler provided a robust abstraction across CPU architectures. Code that ran on one CPU architecture would run on another. It turns out I was wrong. In this post, I provide a minimal example application that demonstrates the importance of field alignment when using sync/atomic and 64-bit values.

package main

import "fmt"

func main() {
	fmt.Println("Hello, 世界")
}

We can build and run this program on our local machine (in my case a MacBook) with the following command.

Learn Go: by Concatenating Strings

hello@bill.dev (Bill) — Wed, 13 Mar 2019 13:02:49 +0000

Joining strings is so common that many of us take it for granted. While working through the exercises in ‘The Go Programming Language’ book as part of the London Study Group, I wanted to understand the differences between the various approaches for joining strings.

If you are looking to concatenate strings in Go, here is what I’d do:

Outside a loop: use the + operator: e.g. `“a” + “b”
Inside a loop: use strings.Join([]string, string)

If you want to know why read on. The notes that follow are primarily for my own understanding. They chart my attempt to explain the results of exercise 1.3 and explore different options for string concatenation.

Beyond the Tour

hello@bill.dev (Bill) — Sun, 24 Feb 2019 20:28:46 +0000

I love watching talks on technical subjects. However, I often find myself in a position where I understand the topic but am far more hesitant when it comes to the importance of the conclusion. As someone who tends to learn the most from practical experience, this lack of confidence often stems from the fact that I haven’t faced similar challenges to the speaker. This presents hurdles when self-learning, as it can be difficult to create complex technical setups required.