Writing concurrent programs is easy, but understanding why they don’t work is much harder. In our continuing tutorial, we’ll learn about when and why goroutines starve, sleep, or yield.
All tagged golang
Go go goroutines: understanding Go’s concurrency model
Our brains can only do one thing at once, but Go programs can manage millions of independently-executing concurrent tasks. Let’s find out how that works, and learn why concurrency is central to Go.
The joy of (type) sets: interfaces and generics in Go
Generics introduces a whole new kind of interface to Go: one based not on methods, but on type sets. Let’s explore the possibilities.
Bobcoin, blockchains, and cryptocurrency
How do cryptocurrencies actually work, though? Join Alice and Bob as they embark on designing a new digital ledger for secure “Bobcoin” transactions.
Slow, flaky, and failing: tuning up your Go test suite
Thou shalt not suffer a flaky test to live, because it’s annoying, counterproductive, and dangerous: one day it might fail for real, and you won’t notice. Here’s what to do.
What are the best Go books in 2025?
What are the best Go books this year? 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.
Rust vs Go in 2025
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?
Undertesting and overtesting: finding the sweet spot for Go tests
Tests are great, provided they actually test something. But are your tests too optimistic (assuming the code already works), or too persnickety (testing the irrelevant)?
Rust and Go vs everything else
Alex Pliutau and I discuss what Go programmers should know about Rust, and why the two languages make perfect partners.
Constraints in Go: tightening up your type parameters
Freedom is nothing without constraints, and Go’s generics gives us a powerful way to build polymorphic types and functions constrained by type sets. Let’s geek out.
Generic types in Go: collections and functions
What kind of idiot would carry a package for someone when they've absolutely no idea what's inside it? Well, generic types in Go are exactly like that, only in a good way.
Testing legacy Go code: tiptoeing through the minefield
How do you rescue a legacy codebase that has no tests? Let's look at some techniques for clawing your way back to maintainability, one test at a time.
Programming is fun: a Cup o’ Go podcast chat with me
I was a guest on the Cup o’ Go podcast recently, talking with Shay Nehmad and Jonathan Hall about writing and teaching Go. Here’s a transcript of our chat.
Encrypting with AES: a simple cipher tool in Go
AES is an amazing, state-of-the-art encryption system, and it’s built right in to Go as part of the standard library. It’s also incredibly easy to use. Let’s see how!
Iterators in Go: the iter package and new stdlib APIs
Iterators in Go are 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, and what new facilities it gives us in the standard library.
Bitfield Institute of Technology
The Bitfield Institute of Technology (BIT) is a software engineering school that offers remote training and certifications in Go and Rust development to students worldwide.
Shameless green: pragmatic TDD in Go
Building software is easy when we’re guided by tests, because we can start with quick-and-dirty solutions, without worrying about whether the code is elegant and readable—yet. Let’s see how to use the TDD technique called “Shameless Green”.
Inside AES: Go’s standard library implementation
The AES cipher is complicated in principle, but the code isn’t all that scary in practice. Let’s take a look at the implementation in the Go standard library. Even I can understand it!
The smallest thing in Go: iota, enums, and magic constants
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: communicating intent in Go
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.