Book Review: Go Programming In Easy Steps

January 27, 2023
Is "Go Programming In Easy Steps" the way to learn Go in 2023?

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. Here are links to the others:

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.


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:

  1. 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

  1. 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.


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.”


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., 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/

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.


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.

Share this

Related Content

What is the Best Book to Learn Go in 2023?

After reading every beginner's book I could find on Go, here is my recommended #1 book to help you learn the language.

Book Review: For the Love of Go

For the absolute beginner to programming, this book will get you started on the right foot.

Book Review: Get Programming with Go

Written for the absolute beginner, this book will leave most wanting much more.