Alex Pliutau and I discuss what Go programmers should know about Rust, and why the two languages make perfect partners.
All tagged Go
Constraints in Go
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
Golang generics open up a lot of exciting new possibilities for us as programmers. In this tutorial, we’ll look at ways we can use type parameters to define customised generic types.
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?
Suite smells: testing legacy code
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
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.
Cryptography in Go: AES encryption
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
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 development to students worldwide.
Shameless green: 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”.
Cryptography in Go: AES 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!
What is 'iota' in Go?
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.
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.
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.
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.