Tutorials, exercises, and articles on programming.

The night is dark and full of errors—and durable Rust software is not only ready for them, but handles them sensibly. Let’s see how, by returning to our line-counter project.

John Arundel

From


 The Secrets of Rust: Tools

Everything that can go wrong

 will

go wrong, as we all know, and that goes double for programmers. With software, everything probably already

 has

gone wrong, but the tests haven’t detected it, because the tests are broken too. Never mind.

Things fall apart

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.

From


 Know Go

Just as you enter the airport security line, a sinister-looking figure slips a package into your hand. “Could you just take this on the flight for me?”

 Sure

, you think to yourself. What kind of idiot would carry a package for someone when they’ve absolutely no idea what’s inside it? Well, generics in Go are exactly like that, only in a good way.

Generic types in Go

In the final sizzling chapter of my career exposé, we’ll learn how I went from self-unemployment to founding the world’s tiniest publishing empire.

From


 My Horrible Career


 The secret of being happy ever after is not to be after too much

This is the end, beautiful friend.

Will write for food

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.

From


 The Power of Go: Tests

Are you writing legacy code? Probably not on purpose, but you might be doing it without meaning to. Legacy code isn’t necessarily

 bad

code, and it probably works, more or less, after a fashion: it wouldn’t have survived long enough to become legacy code otherwise. But it has problems. Legacy code is hard to understand, hard to maintain, and hard to debug.

Testing legacy code

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.

What should you read first when you’re learning Go?

You can’t learn to program from a book, any more than you can learn to fly from reading about birds. The best way to learn, indeed, is by

 doing

the thing. Fortunately, writing software is substantially easier than flying.

What are the best Go books in 2025?

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.

If you’re doing it right, that is

I recently had the privilege of being a guest on the Cup o’ Go podcast, where I chatted with hosts Jonathan Hall and Shay Nehmad about teaching and learning Go. You can listen to the full interview here: Cup o’ Go #21: John Arundel interview Here’s a lightly-edited transcript of the discussion.

Programming is fun

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!

From


 Explore Go: Cryptography

AES is an immensely strong cipher, one of the most effective ways of keeping secrets ever invented. It’s definitely kid-sister-proof, provided you use it correctly. In this tutorial, let’s see how to do exactly that, by using Go’s crypto/aes package to write a simple encryption and decryption tool.

Encrypting with AES

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.

The latest iteration of Go looks interesting

A Golang iterator is a function that “yields” one result at a time, instead of computing a whole set of results and returning them all at once. When you write a for loop where the range expression is an iterator, the loop will be executed once for each value returned by the iterator. That sounds complicated, but it’s actually very simple.

Iterators in Go

Leaving a job is never easy, and it’s a consequential decision. But when it’s time, it’s time. Here’s how to escape the comfort trap, and take the next step in your career.

From


 Code For Your Life

I don’t have to tell you things are bad. Everybody knows things are bad. When you hate your job, no matter how much you try to put up with it, there comes a point where you’re mad as hell and you’re just not going to take it anymore. So, maybe this is the right moment to reflect: is it time to go? Making the decision to leave a job is never easy.

How to know when it's time to go

About BIT   The Bitfield Institute of Technology (BIT) is a software engineering school focused on Go and Rust, but the engineering and design skills I teach are applicable to all programming languages. The school offers remote training and certifications in Go and Rust development to students worldwide. How it works   The BIT program is delivered online, to suit your schedule.

Bitfield Institute of Technology

How do you design user-friendly APIs in Rust? The answer is easy: you use them! Let’s build a simple Rust CLI tool using what I call the “magic function” approach.

From


 The Secrets of Rust: Tools

Coding is easy, but

 programming

is hard—at least, if you’re doing it right.

The magic function

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)?

From


 The Power of Go: Tests

What is well-tested code? We tend to assume it’s something to do with test

 coverage

: that is, if a test exists for each of your functions, they must be well-tested, right? Right? Not necessarily.

Undertesting and overtesting

Thanks to generics, there are some interesting new ways to program in Go. This article explains how we can use

 functional programming

techniques like Map, Filter, and Reduce, and what kind of problems they might help us to solve.

From


 Know Go

Question: what the heck is

 functional programming

, anyway? Don’t all programs use functions? Yes, they do, but so-called “functional programming” takes this idea a step further. Instead of just using functions to organise chunks of imperative code, we can make function calls the main, or only, kind of control structure.

func to functional

Meditation is easy when you know what to do: absolutely nothing! It's hard at first, like trying to look at the back of your own head, but there's a knack to it.

From


 Monk Mode

The grass knows how to grow, your heart knows how to beat, and the Sun and Moon know how to rise and set without your help. None of these things needs your active involvement, and indeed they’ll get on much better without it. Nothing bad will happen if you let go of the controls for a minute.

Catching grace

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.

From


 The Power of Go: Tests

It’s one minute to ship time, and you hit “push” on the very last commit. There it goes: the build is running. Every second counts now, and you watch the test output with increasing impatience. Why do the tests take so darned

 long

? And then, to your horror, the first red lights start to appear. “But these were passing before, and I haven’t touched that code!” you wail.

Slow, flaky, and failing

There are many Rust books, but these are my favourites—and I think you’ll like them too. Here are my reviews of what I think are the truly essential Rust books available today.

I don’t know about you, but I find most technical books are a bit of a waste of money. Either they’re out of date, or about stuff I already know, or I can’t understand what the author is trying to explain. They’re also quite expensive, which makes me doubly cautious about splurging my hard-earned cash.

Seven Rust books that don't suck

The secret of being a great coder is to write terrible code. Wait, wait. Hear me out: I’m going somewhere with this.

From


 The Secrets of Rust: Tools

The secret of being a great coder is to write terrible code. Wait, wait. Let me back up a little. How do we know if code is

 good

, anyway? Surely one of the most important signs is that it’s correct. If your code does the wrong thing, practically nothing else about it matters. That’s why it’s very helpful to write tests.

Writing terrible code

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?

Can I say something without everyone getting mad?

Which is better, Rust or Go—and does that question even make sense? Which language should you choose for your next project in 2025, and why? How does Rust compare with Go in areas like performance, simplicity, safety, features, scale, and concurrency? TL;DR these are two great, but very different languages, both of which are worth your time and attention. Let’s see why.

Rust vs Go in 2025

Alex Pliutau and I discuss what Go programmers should know about Rust, and why the two languages make perfect partners.

Rust and Go make perfect partners

If you want to fly to Mars, a spaceship is a better choice than a tractor. On the other hand, have you tried ploughing a field with a spaceship? So the best tool for the job sort of depends on the job, doesn’t it? That sounds like it should go without saying, but when it comes to programming languages… …

 sigh

… …people love to argue.

Rust and Go vs everything else

You can't clear your mind, or achieve bliss by sitting on a special cushion. But you

 can

start to gently train your brain to stop craving distraction and overstimulation. In this excerpt from

 Monk Mode

, we'll see how.

From


 Monk Mode

The mind is a

 lot

, as perhaps you’ve noticed while owning one. It can be a rather exhausting place to live sometimes. No wonder, when there’s so much going on. Is it possible to get a break from the mind and its endless, restless distractions? Could we dial it all back a little bit, and make some headspace for

 productive

thinking?

Why you can't meditate

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.

From

 Know Go

Ironically,

 constraints

are one of the features of Go that gives us the most freedom as programmers. Let’s talk about that, and explain the paradox. As we saw in Generic types, when we’re writing generic functions that take literally any type, the range of things we can

 do

with values of that type is necessarily rather limited. For example, we can’t add them together.

Blog - Bitfield Consulting

Seven Rust books that don't suck