iota is a neat feature of Go that lets us create “enums”: lists of constants with arbitrary values. Let’s find out how to use iota, with this quick tutorial.
Test names should be sentences
Tests communicate a lot of information, to readers, other developers, and even our future selves. Well-written tests focus on a single unit of behaviour that can be described in a brief sentence, and we can use that sentence as the name of the test.
Programming with confidence: TDD in Go
There’s an easy, pleasant, and reliable way to build software in Go, guided by tests. Let’s find out what it’s like to program with confidence, in the first part of this TDD tutorial series.
Type parameters in Go
Now that generics have come to Go, let's take a look at the new syntax for type parameters. We’ll find out why we need type parameters, how we write them, and how we can use them to create generic functions in Go.
Generics in Go
Generics what now? This friendly, down-to-earth tutorial series explains how Go’s generic functions and types work, why we need them, and where we can use them.
Master of my domain
Let’s talk business—independent business, that is. What’s the cost of being the boss? Some more hard-learned lessons from my own horrible career.
Iterators in Go
The iterator proposal is a neat way to write “lazy loops”, where we never generate more results than we actually use. Let’s see what that would look like in Go programs.
Cryptography in Go: AES explained
AES is the modern standard encryption algorithm, but how does it work? Where does it come from? Let’s kick the tyres with a high-level overview of AES internals.
Rust vs Go in 2024
Which is a better choice, Rust or Go? Which language should you choose for your next project, and why? How do the two compare in areas like performance, simplicity, safety, features, scale, and concurrency?
Best Go books for 2024
What are the best Go books for 2024? Read my (relatively) unbiased recommendations for the Go books you should absolutely buy and read right now, whether you’re a beginner or expert Gopher.
Being a good co-worker is your job now
In the final part of this series on the world of work, we’ll talk about how not to suck at meetings.
Not a real developer
In the second part of my tell-all memoir, we find out why I was constitutionally unsuited to employment in a structured environment, or indeed any environment.
People skills for developers
In the second part of this series on career skills for software engineers, we’ll look at how to deal with that trickiest of species: human beings.
My horrible career
Dev advocate Zack Proser grilled me lightly about my career, and why I haven’t taken any of my own advice. Read the full interview, but pay no attention to the man behind the curtain.
You can do this: surviving day one
It’s day one of your new job as a developer. What should you expect? How should you act? Will you survive “max Q“?
Finding bugs with fuzzing
In the thrilling conclusion to our fuzz testing series, we’ll use Go’s fuzzer to find a real bug in our code, and also to verify the fix.
Writing a Go fuzz target
Let’s continue our exploration of fuzz testing in Go with a look at how to write a fuzz target for a (nearly) realistic function. This time we’ll try to detect a common kind of bug involving a confusion between runes and bytes.
Fuzz tests in Go
Fuzz testing is Go’s clever way of generating new test inputs that you didn’t think of—and that may flush out some hidden bugs. Stand by for things to get a little fuzzy!
The Tao of Go
What is the Tao of Go, and how can we work with it, like a surfer going with the waves instead of struggling against them? By being kind, simple, humble, and not striving; here’s how.
Random testing in Go
Choosing good test cases for our Go programs can be a bit hit-and-miss. What if we could automate that process? Let’s talk about randomisation, property-based testing, and Go’s built-in fuzz testing feature.