Book Review: Go For Beginners

February 2, 2023
This well-written, quick intro to Go for professional developers has some really strong points, but some important down sides, too.

This is the sixth in my series of best books to learn Go in 2023. Read my conclusion or here’s the index for the entire series:

After my bad experiences with two of the previous books, which sorely lacked useful editorial oversight, I was a bit apprehensive about this book, when I saw that it’s independently published.

On the other hand, I love the idea of a “A genius guide”. I’ve often wanted a “X for Geniuses” series, to contrast the “X for Dummies” books, and aimed at people who need some guidance, but not hand-holding.

Let’s see if either my worst fears or highest hopes were justified…

Publication Details

Go For Beginners: A Genius Guide to Go Programming by Edward Thornton, 208 pages. Independently published August 5, 2021.


In contrast to the for Dummies moniker, this book’s subtitle claims to be “A genius guide”, and I think this is appropriately reflected in the target audience for the book. From the introduction, we learn that author Edward Thornton wrote this book with the professional software developer in mind. And the content seems quite consistent with this audience in mind.

Narrative Style

This book is written in a direct, to-the-point manner, which I appreciate, and I think most other professional developers will, too. There’s not a lot of hand-holding going on here, but it’s not so terse as to feel disjointed.

I personally really like the prose style of this book. It feels like it’s speaking at my level (as a professional developer). That may mean that if you’re an early beginner, this book may feel like it’s speaking a bit above your level.


This book is organized in a very logical way, that makes it easy to use as a reference. The first chapter is a very high-level introduction to Go, followed by a chapter on the fundamentals of the langauge; identifiers, filenames, keywords, functions, data types, etc. This chapter on fundamentals does a great job of explaining a bunch of Go concepts concisely and (mostly) accurately. However, I am a bit concerned that it may be a little bit too abstract for those unfamiliar with Go. This is a very difficult problem to solve when writing technical books, of course. The correct balance between abstract concepts and practical examples is a difficult one.

The saving grace for this chapter is that it’s short, so breezing through the abstract concepts may be a good approach, before diving into with greater details in the subsequent chapters.

After the fundamentals, the book goes into more detail on control structures, functions, composite data types, and other highly relevant topics. The table of contents makes it easy to navegate, however the book is missing an index, which may limit its usefulness as a go-to reference.

The last, very short, chapter of the book goes over a few useful patterns and common pitfalls.


I’ve really enjoyed reading this book. The content is written at a level that I, as an experienced developer, can appreciate. It’s straight to the point.

It also does a pretty good job of covering the important Go topics, including the ever-elusive testing package! But it does cover these topics quickly, and not in a ton of detail.

The biggest information gap in this book is one I’ve seen repeated in most of the others as well, and that is in failing to cover Go modules. This book was published in August of 2021, just a week before Go 1.17. But Go modules were introduced in Go 2018, with Go 1.11, and were made the default with Go 1.14 in 2020. So the fact that book doesn’t mention them, and in fact offers very outdated advice about dependency management (the precursor to Go modules), is a bit surprising.

Other than that, this book doesn’t cover generics, but understandably so. Those were introduced a year after this book was published.

And while I don’t see this as a problem, I’ll mention it for completeness sake. While many of the other books touch on topics such as JSON marshaling and unmarshaling, or programming an HTTP server or client, this book does not. Again, I think that’s a valid choice. This book is really more about the Go langauge, than a tour of the standard library. But it’s worth mentioning that you won’t be finding full fledged REST examples in this book.

One last thing I want to mention in this section, which is honestly the largest drawback I found of this book: The code samples in this book (and there are many!) are horribly formatted. They’re written in the same typeface as the rest of the book, and they include no indentation at all, which makes it incredibly difficult to follow. I’m very curious to understand this choice. It looks like laziness on the part of the typesetter (who I assume was also the author), but maybe it was an intentional choice for some reason. Regardless, it’s enough to drop this book from “recommended” to “not recommended” in my view.

If the author would re-publish this with properly formatted code samples, that would improve the usability of this book drastically, and would earn a recommendation from me. And it would be a great chance to update a few things, and add a section on generics.


I found a number of minor inaccuracies in this book. But it’s actually pretty good, especially for what I assume is mostly a solo project, considering this book is independently published.

I found one or two typos in code examples (e.g. { else { instead of } else {), and a few places where an explanation is either ambiguous or technically inaccurate.

One representative example is on page 193 where it says “You can’t use the opening brace { on a line by itself”. The example is talking about a function, where this is actually true. The following is invalid:

func main()

But the statement, taken in isolation, is actually incorrect, because you can start a code block with an opening brace on a line by itself:

func main() {
    /* this is a valid code block */

But I think you’ll agree this type of oversight is not significant.

Physical Charactaristics

Physically, the book is attractive, sharp, and simple. It contains no graphics (other than on the front cover), and that’s perfectly fine with me. The text is easy to read (except for the code samples, as mentioned above). It is a small book, both in terms of page count, as well as physical dimensions, which lends it a sort of “pocket reference” feeling, and I think that’s appropriate, considering the quick and direct approach the book takes.


I really want to like and recommend this book. It has a lot going for it. It’s not nearly as in-depth as Learning Go, but I think that can be a strength, too. I would love to recommend this book for anyone who’s an experienced programmer, and just wants a quick introduction to the Go langauge. But the horrendously formatted code samples are such a distraction, that it really hurts my recommendation. If the code were formatted well, I’d give this a 4-star Amazon review. With the nearly unreadable code examples, I have to dock at least one star. And the outdated (even at time of printing) dependency management section means another lost star.

Bottom line: If you’re an experienced programmer, and you want a quick intro to Go, without a lot of fluff, and you’re willing to look past the poorly formatted code, this book could be a good one for you.

Share this