Golang on A Blog for the Uninitialized

On Regular Expressions

Fri, 13 Mar 2026 10:48:58 -0700

Way back when, I was primarily a Perl developer. I actually did my first interview for LinkedIn in Perl. I always liked that the language was created by a linguist (I legitimately miss using unless).

Today, though, besides the occasional one-liner, I think Perl is most known for its contributions to how we all (now) use regular expressions (this post isn’t going into what they are or how to use them).

Building strings in Golang

Tue, 10 Mar 2026 15:00:17 -0700

How do I build a string in Golang?

Building a string seems trivial, and it generally is, but it’s a great way to dive into further to understand some of the basics around what makes Golang so interesting.

First of all, let’s note that a string in Golang is immutable. That means whenever you want to append to a string, the existing string plus what you’re appending needs to be copied to a new string in memory. This means that when optimizing code, we need to be mindful when we write code that performs these actions many times.

Using the "done" channel in Go

Fri, 27 Feb 2026 14:29:51 -0800

I wanted to document how a done channel is most commonly used.

Mainly because I’ve personally found it to be more confusing than it should be.

It usually looks a bit like this, when following a worker pattern:

func main() {
 var doneCh = make(chan struct{})

 // Perform some concurrent work
 // ...

 // Wait on that work
 for i := 0; i < 10; i++ {
 <-doneCh
 }
 
 // complete
}

I intentially left out a bit here to highlight what a “done” channel actually looks like.

The Worker Pattern

Thu, 26 Feb 2026 16:09:17 -0800

I really like using a worker pattern with unbuffered channels.

API calls, especially when each can be handled separately and independently, are easily implemented with this pattern, and I’ve seen it help tremendously when downloading artifacts for building in CI, for example.

Instead of setting up a buffered channel with a capacity of 10 in an attempt to concurrently handle 10 requests, you can create an unbuffered channel and read from it using 10 workers.

Golang's unbuffered and buffered channels

Wed, 25 Feb 2026 16:40:18 -0800

From the official Go Blog:

Do not communicate by sharing memory; instead, share memory by communicating.

They’re awesome because they enable concurrency support “out of the box”.

They’re basically their own type that implements concurrent safe logic of sharing memory locations of data without the explicit usage of mutexes or locks. The example in the blog link above has some code blocks that show this quite well, actually.

They can be buffered or unbuffered.

A Golang Slice gotcha that...got me

Sat, 21 Feb 2026 12:33:28 -0800

I was doing some self study the other day, feeling relatively confident building out a Trie for an autocomplete function. When checking my work with Gemini, I was recommended something like this as a possible function signature:

func (t *Trie) collect(n *TrieNode, pfx string, results *[]string) {
 // ...
}

Where I started to spiral was the *[]string type in the final input parameter.

That’s weird looking, isn’t it?

In Golang, slices and arrays are often confused. You may say: “But aren’t slices copied by reference?”