Advent 2021: Go

This is a rather interesting entry for me. I’ve been programming for many years and regularly picked up new languages, but mostly out of necessity, not because I was that keen to try out something new. In recent years there have been a few new languages that piqued my interest, notably: Rust and Go. New might be a strong word here as Rust is 11 years old and Go is 12, so let’s go with increasingly popular.

I sometimes do occasionally want to write a small, efficient, super quick to startup tool, or a small, network enabled application. Go is great for that. Or you want a small gRPC client to deploy to your Raspberry Pi? Go is a language that excels in this area for a few reasons:

• It’s simple (and simple to use).
• It has a mature ecosystem.
• It’s robust.

Let me elaborate a bit on each of those. I enjoy using a simple language that works and where I can come back after a while and still understand what I wrote. Go is not my main programming language but it does really well in this department. The syntax is a little bit intimidating if you’re only familiar with C-style languages, but nonetheless I think it’s reasonably easy to understand, even if you never saw Go before. Let’s look at an example here:

func Load(stream io.Reader) (*Settings, error) {
    settings := NewSettings()
    data, err := io.ReadAll(stream)

    if err != nil {
        return settings, err
    }

    if len(data) == 0 {
        // Empty file
        return settings, nil
    }

    err = json.Unmarshal(data, &settings)

    return settings, err
}

Does it look weird? The error handling, maybe, but other than that it’s quite straightforward, and that is a plus in my book. Complex code obviously does look rather complex, but most of the time it’s fairly simple.

The mature ecosystem is also a big bonus for Go. If you want to write a small tool, the last thing you want is picking between 5 different half-baked JSON parsers, and you can see that Go has been used a lot in professional environments. There are libraries available for not so fancy use cases like PostgreSQL bindings and other things you typically don’t see much love for until a language is used by companies a lot.

Finally, it’s a robust language. Memory management is automatic, and the tooling will capture most common bugs during compile time. I was really surprised how quickly I managed to write a working program with good error handling. Go makes this feel really natural and combined with near-instant compile times, fast startup, solid debugging capabilities, and excellent cross-platform support, it’s been a joy to use so far.