Book review: The Go Programming Language, Donovan & Kernighan, 2016

This is a fairly good book to read, especially if you are new to the Go programming language. It also serves as a useful reference while you are getting familiar with the Go language. However, it is not a serious contender for a programming language reference guide such as The C++ Programming Language, by Bjarne Stroustrup. That also makes it somewhat easier to read!


I have extensive experience in many programming languages (C, C++, x86 Assembler, BASIC, Java, C#, F#, Visual Basic) and passing familiarity in several (Lisp, Pascal, Fortran, OCaml, EcmaScript)━I’ve probably forgotten some━but I’m a relative newcomer to the Go programming language and ecosystem.

In the course of the past few weeks I have started my journey in Go, writing fairly substantial utility programs and providing one (so far) small pull request on a major and well-known open source product, Hashicorp’s Terraform. I have also read this book cover to cover, as it is a learning style that has worked very well for me in the past.

Who should read this book?

This is a book for developers, but you should already be proficient with at least one other mainstream imperative programming language (C, C++, Java, C#, etc.) before tackling this book because it does presume a fair amount of basic programming competence.

Obviously, you should be interested in the Go programming language, but ideally you should have opportunity to use it on some real implementation work, ideally something more substantial than the exercises in the book. Those exercises will almost certainly help cement an understanding of the material in the book, but they are not a substitute for real programming challenges, particularly as they guide the reader in the overall design and limit the scope of thinking━exactly what you need in exercises, I think. I didn’t do any of the exercises in the book, that’s just not how I roll.

If you are already proficient in Go, this book isn’t likely to tell you much that’s new━perhaps one or two things about the dangers of code involving uintptr and unsafe.Pointer, but not a lot else. It certainly isn’t going to stop you having to read package documentation, even for standard packages like fmt.

The bad

I’ll present the bad things first so that by the time you’ve finished reading this post━if you make it that far!━you’ll be more likely to remember the good parts.

  • This book won’t take you far into mastery of the language. It will help you become competent, but won’t really get much further than that
  • The authors━or at least one of them━provide some very spurious arguments to justify particular language design elements. For me, these were irritating but thankfully they became less frequent after you passed the halfway mark
  • The early chapters are particularly slow. It’s quite easy to get frustrated at the pace, but if you haven’t promised to provide a review you might find it easier to just skim read those parts, but don’t think you are buying a book with 366 pages of dense language instruction, I think they could have covered the same material in half the number of pages, particularly if they removed or shortened some of the examples

The good

  • This is a good book. I would not call it a great book, but it is a good book
  • The authors appeal to several learning styles: decent textual coverage of content, example code (available to download and play with), guided exercises of varying complexity
  • There is extensive coverage of each language element. Go is a fairly small language with few edge cases, and so there is a decent amount of content for each and every construct in the language
  • The main toolchain (go run, go build, go get, go test, go install, go doc) is introduced, including brief coverage of the way imports are handled, how to develop automated tests and benchmarks, review test coverage and, of course, create executables
  • Decent introductory coverage of how to write concurrent programs in Go (two chapters), including certain design approaches, e.g. event broadcast using close
  • Basic introductory coverage of the unsafe and reflect packages, including a simple example of interfacing with external, C library code

Where to go next

Since the book doesn’t really get to mastery of the language, where do you go for more details?

Book details

  • Alan A. A. Donovan · Brian W. Kernighan
  • Published Oct 26, 2015 in paperback and Nov 20 in e-book
  • Addison-Wesley; 380pp; ISBN: 978-0134190440

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s