It’s 2023, and you want to learn Go. What’s the best book to read to get you on your way?
This question is not as easy to answer as you might expect. Go has changed a lot since it was first introduced over a decade ago. Most recently, the addition of generics in early 2022 render many previously excellent books outdated.
So I set out on a mission to read all the current books on learning Go I could find, so that I can give you an authoritative answer on the best book to teach you Go in 2023.
Of course, learning Go should not end with a book. You’ll want to spend time practicing, asking questions of other Go developers, reading online resources, and browsing code that others have written. If you’re interested in an affordable course or two to help you with these areas, be sure to check out the courses I offer.
This article describes my motivation for an extensive review of learning Go books, my selection criteria, and a little bit about the process itself. And most important, it presents my conclusion, with two, solid “best of the best” recommendations, and a couple of other amazing finds that are also worth your consideration. If you don’t care about the fluff, you can jump directly to the recommendations.
- Why bother?
- Why not write my own?
- Surprises along the way
- Teaching Styles
- The Recommendations
- What’s next?
- List of all reviews
Why bother writing this list, or for that matter, reading a bunch of books about Go? Why not just use the Amazon ratings to pick the best? Great question!
I started learning Go back in 2014 with a copy of Programming in Go by Mark Summerfield. While I found it to be quite helpful, it’s now woefully outdated. And as quickly as Go is changing, most notably with the major addition of Generics in 2022, so are most other Go books.
Further, I felt that a complete survey of all recent Go books could be useful, to find any hidden gems by lesser-known publishers, or even self-published titles. And I definitely found some!
And lastly, most reviews written about books for beginners are the beginners who read them. I believe that a review by a seasoned Go developer, such as myself, can provide a deeper insight into these books.
Why not write my own?
I’ve had a few people suggest that I should just write my own book for those learning Go. I appreciate the vote of confidence!
But there are a few reasons I’m not immediately interested in taking this approach.
- As it turns out, there are already some excellent books out there. It would be difficult for me to do better, at least for this specific topic.
- At a personal level, my bigger interest is in helping software developers improve their productivity through better software development practices. This isn’t unrelated to teaching new people to program, but it is a subtly different focus.
- I’m already producing a lot of Go-related content, and writing a book would take away much or all of the time I have to spend on that.
Of course, most of the content I’m creating is about teaching you Go. And if you’re interested in that content, I’d love to share it with you!
First, you can subscribe to my daily email list, Boldly Go: Daily, where I send daily suggestions and advice to improve your understanding and control of the language.
Second, my YouTube channel has a growing number of tutorials, code reviews, and other Go-related videos, aimed at helping you improve your knowledge of the language.
In addition, I’m developing courses, for a more personal touch than a book can offer. Right now I’m preparing to launch a course on writing tests in Go, which I expect to announce before the end of March. If you’re learning Go, and want to improve your testing abilities, this course is for you! Sign up now, to be notified as soon as it’s available.
“Best” is always subjective. What’s best for one person will not be best for the next.
So before I started the process of reviewing Go books, I needed a list of criteria.
The first, and probably most obvious, of my criteria, when searching for the best book in 2023, is that it’s relatively up-to-date. Generics were introduced to Go in March of 2022, after several years of discussion. So I specifically wanted to find a book that introduces this concept to readers. In a practical sense, this meant I wanted books published after March, 2022. But that list was painfully short, so I extended my search by about a year, on the hope that books published prior to that date may have anticipated the upcoming changes, and written about them anyway. One did!
Second on my list of criteria is that it should be for those new to the Go language. I had in mind that the best book in 2023 would be written for those who already had some experience with programming, but I found a few that don’t make this assumption, and one of them is really good and recommended below.
Third, I want a good book. This is a lot more nebulous than the first two criteria, of course. But in my mind a good book is well written, well organized, free of technical or factual errors, and enjoyable to read. Many things contribute to this, and it’s a bit subjective. I’ve done my best to explain where I believe my preferences color my review, so that those with differing preferences can make an informed decision that’s right for them.
One thing I did not focus on for these reviews is price. While the prices for these books do vary somewhat, the most expensive tops out around USD $50, which, in my view, is a very small investment to make in one’s career and future livelihood. Of course, not everyone is in a situation to be able to afford even that much, and if that describes you, I hope you have access to a good public library where one of these books may be available to you. Failing that, the Internet is still full of great free resources to help you learn Go, or virtually any other language.
One last note on something that was not part of my selection criteria: Sponsorships. I paid for every book I reviewed in this series. I did not reach out to any of the authors or publishers to ask their permission, or to ask for a promotional copy of their book. Nobody has solicited me to review their own book. And I’m not being paid by anyone to promote their book (although some of the links are to Amazon affiliate links, so if you buy one of the books through such a link, I will get a small referral credit).
Surprises Along the Way
My initial search near the end of 2022 for books written in the last 1.5 to 2 years came up with 6 hits. I since learned of two additional books, one published in December, 2022, and one self-published, which I added to my list. I also added two other, older, books to my list, based on reader feedback. The Go Programming Language by Alan Donovan and Brian Kernighan and Get Programming with Go by Nathan Youngman and Roger Peppé are both popular books, and I didn’t want to be accused of failing to include a book that might be in the running, even in light of the fact that it would obviously not include any discussion of Generics.
So that left me with a whopping ten books to read, plus an additional book that’s still being written, and currently available as part of the Manning Early-Access Program. Eleven books in total. Wow!
I’ve enjoyed this process, and I’ve learned a few tid-bits about Go along the way that I didn’t know, even after 8 years of using it professionally (for example: There are two 64-bit architectures that use a 32-bit
int size. Who knew? Well, Jon Bodner knew. Thanks Jon!)
I also received my first YouTube copyright strike for one of my review videos. I contested it, and it was restored.
But by far the best surprise in this process has been hearing from authors of some of the books I’ve written. Thanks specifically to Jon Bodner, Cory LaNou, and Donia Chaiehloudj. It’s great to connect with others who are passionate about helping the Go community grow and learn.
And thank you to all of the other authors, with whom I have not (yet) connected. Even those whose books did not receive my most favorable reviews. Your efforts are appreciated!
If you’ve ever studied a foreign (human) langauge, there’s a good chance you were bombarded with hours of grammar rules. You may have even been good at memorizing these rules, and answering quizzes about whether an adjective comes before or after a noun in your target language.
But if your experience was anything like mine, these memorized rules likely left you a bit lost when it came time to actually speak your target language.
Yo quiero … uhm… una… er.. un… taco de…
In contrast to this grammar-first approach, many langauge courses take a more immersive approach. They teach you how to order your taco (Yo querio un taco de barbacoa, por favor) before they teach you that taco is mascuiline, and therefore should be preceeded by un rather than una, etc. This is more in line with how children learn languages. Ask a 5 year old what an adjective is, and he’ll probably tell you it’s a villian from some sci-fi series on YouTube. But ask him what he wants for lunch, and he’ll tell you exactly what his favorite cuisine is, with few, if any, grammatical errors.
Both approaches have advantages as well as drawbacks. With the grammar-first approach, you get a more logical approach to your new language. Everything has the potential to “make sense” sooner. You’re never told “just do it that way, because.”
On the other hand, memorizing grammar rules doesn’t lend itself very well to conversation. It’s never fluid to pause your conversation to remember how to conjugate a verb, or the proper ordering of a sentence. These rules are really only helpful once they become engrained, and second-nature.
How does this apply to learning a programming language like Go?
Well, there are, broadly speaking, two analogous approaches to learning a programming langauge. With what I’ll call the “concept-based” approach, we learn the rules of the language first, being careful to explain everything from first principles. First you learn data types, then you learn type conversions, then you learn comparisons, then you learn functions, etc. In such an approach, the ordering of the material is often paramount, to make sure the topic you’re explaining only builds on topics already explained, sort of like building a house of cards.
Or on the other extreme, with what is often called the “project-based” approach, we can jump in the deep end and begin writing programs before we understand anything we’re doing. This is approximately how I learned to program on my Commodore 64 way back in the day. I’d type in a program, not understanding a single thing.
Then I’d tweak something, to see what it did. Eventually, I’d read something to explain the concepts. And by then, I was primed to understand those concepts, and put them to practical use. In my opinion, this approach is often the best for absolute beginners, for a few reasons. Perhaps most important, it gives the student an early sense of accomplishment.
Most of the books I reviewed in this series tend toward the first approach. That is, they explain concepts in a logical order, building on first principles, and getting into progressively more involved and complicated concepts (and applications).
A few of the books take a more project-centric focus, starting with code and walking you through the process of modification and tweaking. Get Programming with Go, For the Love of Go, and Learn Go with Pocket-Sized Projects most clearly follow this pattern.
A third category of book, which isn’t as often focused on beginners, is the reference book. Such a book is usually organized by topic, with a rich index, to make it easy to find a particular topic when you need it. Unlikes the previous two categories, reference books are generally not intended to be read cover to cover.
Alright. I know this is the bit we’ve all been waiting for, so let’s get to it!
Learning Go: An Idiomatic Approach to Real-World Go Programming by Jon Bodner stands out as my #1 recommendation to anyone with programming experience who wants to learn Go in 2023. If you are absolutely new to programming, I suggest that consider my alternative recommendation, below.
This book goes wide, with the topics covered, and deep enough for anyone to get started. It generally takes concept-based approach, mostly building on first principles as the book progresses. However, it doesn’t adhere strictly to first-principles order, and instead opts to occasionally introduce a topic just enough for the current context, while pointing you to the later section of the book that goes into detail on the concept. I really like this approach, as I think it provides the ideal balance of the concept-based based approach, while maintaining a reasonable order that makes the book useful as reference material.
This book does an impressive job of thoroughly covering the essential elements of Go. A key feature I like about this book is the way it calls out a number of common “gotchas” that will trip up many newcomers to the Go language. For example, on page 32 it explains unused variables:
Another Go requirement is that every declared local variable must be read. It is a compile-time error to declare a local variable and not read its value.
This book is generally free from technical errors, and even many of the outdated bits have been updated (if you purchase a recent printing) to indicate what has changed. And chapter 15, which covers generics, has been heavily updated since the initial printing, and is available free online for anyone who purchased an early printing of the book (before generics were actually included in the language).
Word from the author, Jon Bodner, is that a second edition of this book is also in the works, presumably to coincide with the release of Go 1.22, based on some of his comments. I’ll be watching for that in 2024!
Best for the Absolute Beginner
This book starts at the beginning, having you install Go on your computer, initialize a Go project, then walks you through some Go projects, putting this book squarely in the project-based camp.
What I really love about this book (as well as Learn Go With Pocket-Sized Projects), is that it takes testing seriously, which is essential for professional developers, or even serious hobbyists. From the very first project, you’re introduced to the concept of testing your code, and this book even goes so far as to explain how to write your tests before your code, and why this isn’t as crazy as it sounds.
Go Fundamentals by Mark Bates and Cory LaNou is an excellent book that didn’t quite make my #1 recommendation spot for a couple of reasons. But I still love this book, and think it could be a great second book on Go for many people, or a good first book for someone who’s already superficially familiar with the Go language, and is looking to flesh out their understanding.
The biggest reason this book isn’t my #1 recommendation has to do with the way this book is organized. In the words of the authors, they went “through great effort to try to make sure that examples and chapters don’t contain any new information that we haven’t covered up to that point.” While I applaud this effort, it makes for some awkward ordering of some topics, and means that you’ll need to read several hundred pages of this book before you have broad enough understanding of Go to begin to be productive. This may be the most extreme example of a concept-based book that I read. Of course, if you appreciate that, this book is for you. 😊
A secondary reason that I chose Learning Go as my #1 pick is the breadth of information contained with in. This book goes deep on all of the critical topics for a modern, professional Go programmer. However, Learning Go goes a bit broader, covering more topics, but with a little bit less depth in many places (although still notably detailed in some cases). For most people new to the langauge, I believe that that breadth of topics is more important than depth.
As I was reading my stack of books for this series, I became aware of a book that’s not even complete yet. Learn Go With Pocket-Sized Projects by Aliénor Latour, Pascal Bertrand, and Donia Chaiehloudj, is available from the Manning Early Access Program (MEAP), which means you can pre-purchase the book, and read it (and even provide feedback) as it’s being written.
At the time of my review, the first four chapters were available. And I was impressed!
True to the title, this is a project-based book, with each chapter introducing a project, and walking you through a number of modifications that introduce you to new Go concepts along the way.
As with For the Love of Go, this book takes testing very seriously! Even the ubiquitous “Hello, World” example is presented with tests.
As the book is only about one third complete, I cannot offer a complete review, but I like what I see so far, and when the book is finalized, I intend to do a complete review. I’ll of course announce that reivew on my daily mailing list, as well as put a link here.
As a bonus, Manning has generously offered a 45% discount to my readers and viewers through May 3. Use coupon code BOLDY45 when you purchase this book for your savings!
Where do we Go from here?
I’ve received many requests for reviews of other Go-related books, which aren’t specific to beginners to the language. So watch this space (subscribe to my daily list to be notified!) for additional book reviews in the future.
I’ll also be keeping my eyes open for new books aimed at Go newbies, and update these recommendations at least once per year as the available books (and Go’s important features) change.
List of all reviews
Below is a listing of each of the written reviews I did, or you can jump to the playlist on YouTube if you prefer to watch.
- Go Programming Language for Dummies by Wei-Meng Lee
- Go Programming In Easy Steps by Mike McGrath
- 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