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: how I started my own business
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.
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.
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: transitioning from IT to dev
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: how to thrive in a diverse team
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: how it started vs how it’s going
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 as a new developer
It’s day one of your new job as a developer. What should you expect? How should you act? Will you survive “max Q“?
Fixing a fuzzed-up function: Go fuzz testing explained
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.
Target acquired: fuzz targets in Go tests
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.
What the fuzz? Introducing fuzz testing 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: writing software with kindness
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 and property-based 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.
The adapter pattern in Go: designing decoupled abstractions
How do you test a database without a database? Don't worry, this isn't one of those Zen puzzles. I have something more practical, but equally enlightening, in mind. Let’s use the adapter pattern to solve the riddle.
Generics in action: a set type in Go
To celebrate the first anniversary of generics in Go, let’s build something practical and useful: a generic Set type, and add some neat methods to it. Ready for fun?
From packages to commands: writing testable Go modules
In Part 2 of a series about writing packages, not programs, we see how to test a package that prints to the terminal, and use the result to build our “hello, world” CLI tool.
Write packages, not programs: reusable components in Go
Go has a great standard library. What if we think about our work not merely as building one-off programs, but instead contributing packages to the universal Go library?
Death by a thousand nits: the art of productive code review
Could we give and receive code reviews with kindness, gentleness, humility, and compassion? Can we make a point without making an enemy? Let’s go line by line.
A career ending mistake: choosing your exit strategy
As software engineers, we're constantly making detailed, elaborate plans for computers to execute. Isn't it weird that we rarely give a moment's thought to the program for our own careers?
Go’s best-kept secret: executable examples
Did you know that Go lets us provide executable code examples as part of our documentation? It’s pretty neat. Let’s take a tour of this useful feature and see how it works.