Review: 'Let's Go Further'
New: Let’s Go Further is featured as one of my Best Go Books!
Alex Edwards's name will be familiar to Gophers, as he's the author of many Go tutorials, as well as the excellent book Let's Go, an opinionated walkthrough of the development of a full-scale web application in Go. He's been working with Go and writing about it for many years, so he brings both wide and deep experience to the subject.
Higher, further, faster
His new book, Let's Go Further, promises more of the same, guiding you through "the start-to-finish build of a modern JSON API in Go – from project setup to deployment in production." So who is the book aimed at, and does it deliver on its promise?
It's always a good sign when a writer has a clear idea of his audience, and Alex is aiming this book squarely at fairly experienced developers: those with at least one or two years of commercial Go development under their belts, perhaps, and who are already familiar with things like JSON and REST APIs.
Having also covered a lot of ground in the previous Let's Go, he rightly doesn't revisit that material here, so you should read that book first if you haven't already. Let's Go Further builds on its predecessor to deepen your understanding of practical Go applications, and show how considerations of scale, security, and performance should factor into your designs.
What's in the box?
What do you get for your money? Well, it's worth saying up front that Let's Go Further is an enormous book, at well over 1000 pages, 21 sections, 83 chapters and six appendices. It's hardly light reading, but then this is a deep and highly technical subject, and the book tackles it with an admirably comprehensive attention to detail.
Alex builds up a complete, realistic application, piece by piece, expanding it as he goes and explaining how each part works and why it's necessary. The code is heavily commented: so much so, indeed, that it's hard to follow the code sometimes. But I think this works better than having a line of code, a line of text to explain it, another line of code, and so on.
If you're copying and pasting the code into your own programs, which is clearly the intention, then the detailed inline comments will come with it, meaning that you don't need to constantly refer back to the book.
I think most of us, having got the hang of the fundamentals of Go, probably learn best how to write real programs by looking at other people's code, and that's very much the idea here. The example application is thorough and well-written, and repays careful study.
The most valuable thing about this book, though, is Alex's advice about all the little things you can only learn from experience: common traps, gotchas, and footguns, places where it's easy to make a mistake or introduce a security issue unless you know what you're doing.
Covering all the angles
A lot goes into building a real-world application, beyond just the Go code itself. A good API needs to be able to accept user data in a variety of formats and structures, parse it intelligently, and return helpful information to the user when it's not quite right.
You also need to be able to organise your code into suitable packages and modules, deal with databases, email interactions, authentication, logging, security, metrics, builds, deployments, releases, hosting, and a zillion other things. Suffice it to say that Let's Go Further covers all these topics in detail, plus many more.
As a writer, it's sometimes difficult to know what not to include in a book: there are always bits of important and useful background knowledge that we'd like to put in, even if they're not strictly essential. Some things are just worth knowing, and worth explaining, on their own merits. Many things in Let's Go Further fall under this heading, and Alex acknowledges that:
This chapter contains quite a lot of theory, and although it’s interesting, it’s not critical to the application build. If you find it too heavy-going, feel free to skim over it for now and then circle back to it later.
This is a nice approach, because it makes clear which content you can skim if you're in a hurry, and it means that Let's Go Further will keep delivering value even on multiple readings.
Shut up and take my money
Alex kindly provided me with a copy for this review, but I'd have no hesitation in purchasing the book for myself and anyone else on my team if I were working on a large commercial web application or API server in Go.
At just under sixty dollars for the "professional package", including complete code listings, exercises, and printable crib sheets, Let's Go Further represents terrific value. It's nice to see that Alex also offers a 25% discount for students, as well as sensible pricing options for small and large teams: this is a book that companies will want to invest in if they're serious about Go.
Let's Go Further is both an essential reference for Go developers and a valuable compendium of battle-tested knowledge about using Go in practice. Its examples are sufficiently realistic to be usable directly in production, but also sufficiently general to be adaptable to most codebases. Don't leave your comfort zone without it.
