I’m on a mission to find the best book to learn Go in 2023. This is the second in my series of book reviews. Read my conclusion, and here are links to the other individual reviews:
- Go Programming Language for Dummies by Wei-Meng Lee
- Go Programming In Easy Steps by Mike McGrath (this post)
- Learning Go by Jon Bodner
- Beginning Go Programming by Rumeel Hussain and Maryam Zulfiqar
- Learning Go Programming by Shubhangi Agarwal
- Go For Beginners by Edward Thornton
- Learn Go With Pocket-Sized Projects by Aliénor Latour, Pascal Bertrand, and Donia Chaiehloudj
- Go Fundamentals by Mark Bates and Cory LaNou
- The Go Programming Language by Alan Donovan and Brian Kernighan
- Get Programming with Go by Nathan Youngman and Roger Peppé
- For the Love of Go by John Arundel
Publication Details
GO Programming in easy steps: Learn coding with Google’s Go language; by Mike McGrath, 192 pages. Published January 26, 2021 by In Easy Steps Limited.
Audience
The back cover claims this book is “ideal for newcomers, students and experienced programmers wanting to quickly grasp key Go features.”
However, I think any experienced programmer would find this book to be too basic, and lacking in detail.
Narrative Style
The book is written in a fairly straight-forward, matter-of-fact style.
If you want to store a fixed value that will never change during the execution of your program, you should declare it using the const keyword, rather than the var keyword. This prevents accidenta (or mischevious) attempts to assign a different value.
Where I find the narration style to be annoying, though, is I guess in its main feature. The “easy steps” it offers are a bit awkard, and feel forced, I guess to satisfy the book’s title feature:

- Create a function that requires an integer argument and will return an integer value and an error
func isPosInt( num int ) ( int, error ) { // Statements to be inserted }
- Next, insert a conditional test to return an error, or the argument value — depending on its value
if num < 1 { err := fmt.Errorf( "%v not a positive integer", num ) return -1, err } return num, nil
I would much rather just see the code I’m expected to produce, in its complete form, perhaps with inline commentary, rather than this step-by-step narration style.
Content
If it weren’t for the bulky physical dimensions, I might describe this book as a beginner’s pocket reference to Go. Topics are each addressed on a sigle 2-page spread, that makes it ideal as a reference.

The downside of this is that it’s not a very natural tuturial. While most topics include executable code samples, there’s no natural build up of concepts, to help you build a useful application. Rather, you’re presented with a bunch of fairly disjointed concepts, and left on your own to put them to use in a real-world application.
Near the end of the book, we do finally see some examples that build on each other.
In the chapter on HTTP, for example, we first build a minimal HTTP Server, then in the next example, we add the ability to respond to requests, then add the ability to serve static files.
I do find it a bit annoying, that the code examples include a lot of extra horizontal and vertical white space. I’d even say this is hypocritical, considering the advice offered on page 17: “It is good practice to always ensure your Go source code is properly formatted by the go fmt tool.”
Due to the early publication date, this book is naturally missing any discussion of generics, which were introduced in Go 1.18. Sadly, it also overlooks Go modules, which I’ll talk about more in a moment. And as with Go Programming Language for Dummies, there’s no discussion of writing tests with the testing
package.
And of course, as one might expect for a book of a mere 192 pages, details are very sparse throughout the book. Many data types are not mentioned at all (float32
, integer types other than int
, etc), and there’s no discussion of type assertions at all.
In the two-page spread on converting between strings and numeric types, for instance, it mentions strconv.Atoi
, strconv.ParseFloat
and strconv.Itoa
, and nothing else. And no mention anywhere that I can find of type assertions.
Oddly, there is a two-page spread on goto
. But to the book’s credit, it does say in the introductory paragraph “[goto]’s use is frowned upon.”
Accuracy
The very first chapter of the book, about installing and configuring Go on your local machine, is very outdated. What’s worse, it was already mostly outdated at the time this book was published.
It instructs the reader to configure their GOPATH
, which is made obsolete by Go modules, which were first introduced in Go 1.11 in 2018, and was made the preferred way to use Go with the release of Go 1.14 in February of 2020, nearly a year before this book was published. In fact, on page 10, where it talks about installing Go, it references Go 1.14.4, so there’s really no excuse for this oversight, even for a book this old.
Every example in the book also instructs the reader to create Go packages with “invalid” names. Proper Go package names include a fully qualified domain name (e.g. github.com
), and the full path to the package. This was true even before the introduction of Go modules, though Go modules do enforce it more strictly. So where the book advises creating $GOPATH/src/foo
, it should instead suggest, for example, $GOPATH/src/github.com/user/foo
.
Physical Charactaristics
The most salient feature of this book is the bright, glossy color pages. The syntax highlighting in the examples is a nice touch, though for my taste, this niceity is far outweighed by the annoying “steps” narrative format.
Otherwise, we mostly see colorized step number indicators, and clip art throughout the book margins. The main utility the colors provide is that each chapter has the page numbers printed in a different color along the fore edge, making it easy to jump to a particular chapter.

Conclusion
This is a beautiful book. The full color, glossy format is nice to look at. But the awkward narration style and lack of depth leave me quite disappointed. The fact that the book is so outdated with regard to modules is just a final nail in the coffin. I’m honestly surprised to find a book I like less than the first one I reviewed, Go Programming Language for Dummies.