Learning to program can be both challenging and terrifying. Not only are you starting off on a challenging task, but you are often doing it without a map to guide you. While I can’t make learning to program easy, I can help you evaluate the Go resources out there and determine which of those will be suited for your needs.
Everyone learns differently, so I can’t promise that you will love them all, but I suspect you will like most of them and will be able to find plenty that do meet your needs.
This guide is also intended to be helpful to pretty much anyone learning Go; that means both absolute newbies and experienced developers should both be able to find useful resources and a path to success.
Don't try to read everything
This guide is meant to be fairly exhaustive, but please do not feel like you need to read all of the resources mentioned. Many of them cover similar information, or material you may already understand. The purpose in providing as many resources as I am is to give everyone options to choose from knowing that all of them are good choices.
If you have programming experience, I would first suggets starting out with the Go Tour - https://tour.golang.org/welcome/. This will help get you familiar with the syntax in Go and is a nice quick introduction. While the tour is great for experienced developers, I don’t feel like it is great for newbies so keep that in mind.
After that you have to decide what you think is best. You can jump down to the Getting Help section and move on from there, or you can look at some of the resources in the next section and read one of them. For instance, Applied Go’s Master Course is a great way to learn a lot more about the language and would give you a big step up as you move on through this guide, or you might be more comfortable jumping to the books, courses, and exercises mentioned in the Improving as a Developer section of this guide.
If you are looking to learn how to program in general, the biggest piece of advice I can give you is to simply program a lot. It doesn’t matter if you are writing silly programs that are useless or building trivial number guessing games. Your goal at the start shouldn’t be to write the most elegant code, or to build the biggest, baddest web application, but simply to become familiar with the language, the syntax, and the tools you are using. This also means that you shouldn’t be copy/pasting code you find in tutorials or courses, but instead should try to code everything yourself even if reading it from a video or book. Actually writing the code will help you learn it much faster than copy/pasting it.
It is also worth mentioning that oftentimes when learning new material, not everything you are learning will sink in right away. This is where repetition and persistence will truly pay off - you have to stick with it and keep practicing and slowly those concepts will start to “click.”
A great example of this is the way Mattan, a co-founder of One Month, learned web development by forcing himself to complete four large Rails tutorials in one month. Each course took him about a week to finish, and when he talks about it he admits that there were sometimes things he didn’t quite understand, but every time he went through a new course it improved. By the second course he understood enough about programming and the language to start to pick up on slightly more complex topics, and he continued to understand more each pass.
Learning to program is often done this way - you sometimes just have to do things you don’t quite understand so that you can eventually get to a point where you can come back and understand it all. It sounds weird, but it is true.
Now enough talk - let’s jump into resources that I feel are helpful for getting started with programming and Go.
Todd McLeod's Courses and Videos
Caleb Doxsey's FREE Book
Caleb’s book is a great resource for getting familiar with the syntax of Go and writing some basic code. It is also free, which means you can check it out without any cost.
Caleb’s book, An Introduction to Programming in Go, can be downloaded free or you can buy a print copy on Amazon.
GolangBot.com's Tutorial Series
This is another great free resource intended to help you get familiar with Go. The tutorial series is broken into around 30 tutorials each designed to teach you a small aspect of Go. By the end of it you should be fairly familiar with using the various features of the language.
You can find the tutorial series here → https://golangbot.com/learn-golang-series/
Applied Go's Master Go Course
After you get the syntax of Go down and get roughly familiar with using the command line, I highly recommend checking out Christoph Berger’s free articles and his paid course. All of his content is incredibly thorough, and he creates really nice visuals to help explain some of the more complicated subjects.
The course isn’t intended for absolute beginners, but if you complete any of the other material in this section then I suspect you could start jumping into this course and get a ton of value out of it. Plus, you can always revisit it later when you get better to help build a rock-solid foundation in Go.
You don’t need to read/watch all of these resources, but if you do I promise you will have a pretty solid grasp of all the basics in Go, which will prepare you to start working on projects and developing your skills as a programmer. While doing this, it is likely that you will run into issues and need help, which brings us to our next section.
Assuming you have a little programming experience and have started coding pretty much anything, you are going to run into issue. You will encounter a bug you can’t fix, find odd behavior you don’t understand, or something else along those lines.
When that happens you should definitely try to solve the problem on your own. Learning from your mistakes is a major part of learning to program, as is getting better at Googling for help. Once you have tried to help yourself you can move on to asking for help.
The first step to solving an issue is to slowly walk through the execution path of your code and to explain what is going on at each step. You don’t have to explain it to anyone, but it is important to stop and make yourself evalutate what it is actually doing, not what you think it is doing. Some people call this “rubber ducking,” which stems from a programmer explaining his code to a real rubber duck.
Once you have walked through the code path, if you still can’t see what is wrong then try to at least isolate where the issue is occurring. That is, figure out when your data stops being what you expect, or where in your code you are getting an error you don’t expect. From there see if you can find anything useful to Google. For instance, if you are seeing a specific error message, try searching for it with quotes around the generic parts and looking at any Stack Overflow or similar articles that you find. This is by far one of the simplest, yet highly effective techniques that experienced devs will use.
If after doing all of this you still can’t figure out the issue, then it is probably time to ask for help.
If you are just getting started with Go, the first thing you will want to know is where to turn when you get stuck. We will get there in a moment, but first I think it is good to lay out some ground rules and discuss how to get the best help possible.
For starters, make sure you tried to solve the problem on your own. That is covered in the previous section, and it is super important.
After that, try to create the smallest version of your code possible that still replicates the issue. Ideally you want as few lines of code as possible while still being able to share runnable code that illustrates your issue. You will want to include all of this when you ask your question.
I also recommend including what you have tried and Googled already; not only will this let people know that you have tried to solve the problem on your own, but it will also prevent them from trying the same things and wasting their time. Remember, it is a human on the other end of those forums helping you, so anything we can do to make it easier for them to help us is always appreciated.
Finally, try to keep your questions as specific as possible. Nobody likes helping someone who posts, “How do I write a program that does X.” It just feels like the person asking the question didn’t try anything on their own and just wants us to do their work for them, whether it is homework or another type of work. Questions that are too vague, or require a massive amount of effort on other people’s part are way less likely to get answered, so asking a short and simple questions - even if you have to ask followup questions later - is a better path to success.
Okay, now that we have a proper question to ask, here are some places to ask it:
Places to ask for help with Go
Remember to search for your question before asking
Some of the resources listed above are realtime, which means there likely isn’t a way to search for past questions, but if you are asking in a forum or somewhere else with a search feature be sure to use it. While it might be the first time you are experiencing an issue, many common questions get asked very frequently and after a while developers get tired of answering the same questions. If you can do anything to help them avoid the monotonous task of answering the same question 50 times, you should. 👍
Okay, so you know how to code some basic stuff and you know how to ask questions. Now the question is, how do you continue to improve as a developer? How do you get beyond those trivial apps and into the realm of building real projects?
Learning the syntax of a programming language is relatively easy - that’s why we have so many “Learn X in 30 days” books - but actually becoming an experienced developer who understands how to design and implement a complex solution takes time and practice. Go isn’t just new syntax that you can master in thirty days. Sometimes the best way to solve a problem is non-obvious, and it is important to continuously learn from others and to adapt as your requirements change. As a result, my general advice for improving as a developer is to spend at least 50% of your time coding things, while spending maybe 25-50% of your time learning from external resources in order to learn things you may not think of or encounter naturally.
What resources you reference depends on what you are interested in and the medium you prefer. Some developers prefer shorter tutorials, articles, and the standard docs and piece them all together on their own. Others prefer larger books and courses, and finally some developers prefer to look through the source code of larger projects to learn how those teams are tackling problems. Rather than trying to pin you into one of these, we will cover a little of each.
We’ll start off with exercises and tutorials that you can code along with, and that ideally aren’t incredibly large. These are typically great when you don’t know what to build and just want to get a wide variety of different types of projects under your belt.
The most efficient path for improvement is to pick projects that push you outside of your comfort zone, while also not pushing so far that you don't even know where to start and just get stuck. The problem most developers run into here is going to far in one direction or the other. They either get stuck building simple applications over and over again without learning anything significant, or they pick a project that is so far outside their skillset that they can't ever finish it and quit out of frustration.
Gophercises is a FREE course created by Jon Calhoun (me!) after talking with many developers who were experiencing this issue. It is split into around 20 mini-exercises that are each designed to teach you something new while not pushing you so far that you will get stuck or lost. Each exercise starts with a description of the problem and some helpful hints for solving the problem on your own, and is followed by a video of Jon walking through the exercise and coding a solution while explaining his thought process along the way. The primary benefit to this approach is that you can try to solve each problem on your own, but if you ever get stuck there are always videos to fall back on to learn a viable solution.
You can check out the course here → https://gophercises.com
Just for Func
Just for Func is a YouTube series by Francesc Campoy where he creates small projects in each video designed to teach you something new about Go. Sometimes he does code reviews, showing you how to improve your overall code design; in other videos he will walk you through creating Flappy Bird in Go, or using Kubernetes.
No matter what the video topic is, you are bound to learn something new about Go and will learn a lot watching another experienced developer as they code.
You can find Francesc’s YouTube channel here → https://www.youtube.com/justforfunc
Exorcism provides many small, well defined exercises that are intended to help you improve your programming skills. When you solve a problem you can run it against tests and submit it to the website for peer feedback which can be incredibly helpful for improving your code quality.
While Exorcism isn’t Go specific, it is likely to be helpful in your journey to learn any programming language including Go.
You can find more info here → http://exercism.io/
While exercises and tutorials are a great way to learn a new language, they typically only focus on smaller scoped lessons and problems. For instance, it would be incredibly hard to teach someone everything there is about testing in a few short tutorials, but this would be a great subject for a book or course that spans many hours of content. In this section we are going to cover some courses and books that would be useful for any budding Gopher.
The Go Programming Language
The Go Programming Language is written by Alan A. A. Donovan and Brian W. Kernighan, and is generally considered one of the best books to start with when learning about Go. The book covers just about everything necessary to get a good understanding of the language and how it works, and goes well beyond learning just the syntax. Even if you know Go, this is a great read.
You can find the book here → http://www.gopl.io/
Go in Action & Ultimate Go Programming
William Kennedy is a well known and respected author and teacher in the Go community. He has given countless trainings on Go, and his talks are always worth attending. Both his book and video courses are the result of his experience teaching many new Gophers, and are definitely worth checking out.
You can find his book, Go in Action, here → http://www.goinactionbook.com/
You can find his video course, Ultimate Go Programming, here → https://www.safaribooksonline.com/library/view/ultimate-go-programming/9780134757476/
Get Programming with Go
Get Programming with Go is written by Nathan Youngman, who is a contributor to Go’s open source ecosystem and an organizer of the Edmonton Go meetup. The book will serve you best if you check it out after learning how to write some programs and are ready to start mastering your programming skills.
You can find Get Programming with Go here → https://yng.mn/programminggo
Web Development with Go
Web Development with Go walks you through creating a real web app from scratch and then deploying it to a production server. You start with a 15 line web application and gradually build upon it until you have a complete photo sharing web application. In the process of learning web development you will also learn a lot about programming in Go, as the course also covers things like functional options and design patterns.
I tried to make this accessible to beginners, but you may need to spend a little time outside the course to learn some new concepts. For instance, the course covers how to create HTML pages using templates in Go and how to include Bootstrap CSS, but the course doesn't cover what CSS selectors are; instead you are referred to external resources (like this guide!) to learn those topics.
You can check out the course here → https://www.usegolang.com
Full disclosure, I am the author of this course.
Applied Go's Master Go Course
This course was mentioned already, but it fits this category as well.
Christoph Berger has many great free articles and a paid course that are worth checking out as develop your Go skills. All of his content is incredibly thorough, and he creates really nice visuals to help explain some of the more complicated subjects.
Many people will suggest that you check these out before almost anything else, but I have mixed feelings on that feedback. Several of the resources, like The Go Tour, are great for experienced developers to dive into, but if you are relatively new to programming most of these resources are likely to go over your head and just confuse you, or at the very least be less effective than other resources.
That said, you should eventually check out each of these resources. They will help you truly understand the Go language.
The Go Tour
The Go tour is an interactive tour where you can see, modify, and run code to get a feel for how Go works. It is ideal for developers who have experience with another language and just want to get a quick glimpse into Go. You can find it here → https://tour.golang.org/welcome/1
The Go Programming Language Specification
Language specs are generally considered to be boring, exhausting things to read, but Go has tried to make theirs more accessible. As a result, many developers suggest Go devs read it so that they really understand the languages is parsed behind the scenes. You can find it here → https://golang.org/ref/spec
How to Write Go Code
This tutorial illustrates how to use the
go tool in order to develop a simple Go package. It is much more accessible than the language spec, and you should read it fairly early on in your Go career. You can find it here → https://golang.org/doc/code.html
Effective Go is a fantastic resource that helps teach developers how to write clear, idiomatic Go code. It is intended to be used in conjunction with most of the other articles in this section, but in my opinion it is the most important article to read in this section. You can find it here → https://golang.org/doc/effective_go.html
Standard Library Documentation
Every package in Go’s standard library has great documentation, so when you want to start to use a new package, or are curious how another package works, you should start with the docs. They can be found here → https://golang.org/pkg/
Go's Source Code
If you are ever looking for ideas on how to design code or want to see how something is implemented, you should check out Go’s source code. You can find it here → https://github.com/golang/go
Lastly, if you are looking for more articles or tutorials you can check out the rest of the docs provided by the Go team here → https://golang.org/doc/
When joining a new development community, it is often a good idea to find out which members of that community write a blog and figure out which of those you enjoy reading. While books and courses are incredibly powerful in teaching complex topics, they take a long time to create. As a result, blogs are much better suited for teaching about hot topics that arise, or to teach about something that is evolving relatively quickly. They are also a better place to find opinion pieces that will help shape you as a developer, as a blog is clearly composed of a specific author’s opinions while a book or course is often expected to be just the facts.
I can’t tell you exactly which of the writers in the Go community will be a good fit for you, but I have tried to compile a large list of options below. I also included some related material - like the Go by Example website - which aren’t strictly speaking blogs, but can serve a similar purpose.
Go By Example
Go By Example is a large collection of example programs that help illustrate how to achieve various goals in Go. Each code sample is annotated to explain what the code is doing, and can be a great way to quickly find out how to complete a task. For instance, you that wanted to know how to open a file in Go you might reference this page to get up to speed quickly.
You can find the website here → https://gobyexample.com/
Go Web Examples
Go Web Examples is similar to Go By Example, but is focused on providing examples of how to accomplish common web development tasks.
You can find the website here → https://gowebexamples.com/
Calhoun.io is Jon Calhoun’s (that’s me!) website where he published Go tutorials that will help you learn to do fairly common tasks in Go. He also has a few multipart series that can be incredibly useful when diving into a more in-depth topic like Go templates, using PostgreSQL with Go, and basic CS algorithms and how to implement them in Go.
You can find the website here → https://www.calhoun.io/
Dave Cheney's Blog
Dave Cheney is a programmer who has been contributing to Go since 2011. He is a staple in the Go community and his articles are always well thought out and explained.
You can find the website here → http://dave.cheney.net/
Ben Johnson's Blog
Ben doesn’t write very frequently, but the articles he produces are insightful and well worth your time.
You can find the website here → https://medium.com/@benbjohnson
Applied Go Blog
This was mentioned earlier, and is created by Christoph Berger.
You can find the website here → https://appliedgo.net/
William Kennedy's Blog
Originally called GoingGo.net, Bill started his blog when he first started learning Go and has since become one of the most prominent providers of Go training. His articles are thought provoking, and he writes fairly often.
You can find the website here → https://www.ardanlabs.com/blog/
My go-to spot for finding useful libraries, articles, and tips on using JSON with Go.
You can find the website here → https://pocketgophers.com/
If I am missing a great blog let me know - I know I read more than this but haven’t had the time to actually take not of which blogs I have been reading lately.
There are also a few mailing lists that will deliver quality articles to your inbox every week, making it easier to discover great content and new authors on the Go community.
And here are a few mailing lists that aggregate posts from various authors.
This is the biggest Go newsletter that I am aware of and is the one I would start with. You can find it at http://golangweekly.com/
I haven’t seen a new email from this list in a while, but just in case I am including it. http://golangweekly.com/
Below are some of the common questions I get asked from people learning Go.
If you are looking for an editor, here are the good ones I know of:
Sublime Text - Again, you need some plugins. GoSublime is the most important one iirc. I used to use this for Go, but have since moved over to Atom for Go code. I still use atom a ton for writing markdown, editing JSON files, and many other tasks.
Goland - This is the Jetbrains Go IDE. It is supposed to be very good, and has an awesome param tooltip that I wish was in Atom.
VS Code - You will need plugins here as well, but I’m not 100% sure which ones are best. A few google searches should help you out. You can see it in action in the Just For Func series by Francesc Campoy.
If you need to debug a Go program, the first thing I would suggest is using print statements. For simple bugs this is often plenty to figure out where your logic is going wrong. If you have a complicated enough situation you can also find extensions/plugins for nearly every editor or IDE that uses Delve.
I get asked this one a good bit, so I’m adding a small section for it.
If you want to dynamically reload your code every time it changes, I have found github.com/pilu/fresh to be the simplest way to get this working. It isn’t perfect, but works well enough to serve my needs.
I have a video where I introduce this on youtube. It is part of my course sample, but it works as a tutorial on its own as well.
If you are looking for resources to help get you started with these topics I recommend that you check out one of the following.
Michael Hartl created the Rails Tutorial, which is generally considered one of the best resources for learning Ruby on Rails.
There are subreddits for almost anything you want to learn. I would suggest checking them out for ideas of other resources you can leverage.
The link goes to Amazon with no affiliate program, but it does use smile subdomain.
This is supposed to be a good tutorial for getting into HTML & CSS, but again I haven’t read it. I am just trusting it based on reviews from others.
This is a really cool interactive demo once you are familiar with basic CSS. Namely, once you understand what selectors are this is an interesting and useful read.
I haven’t taken this course, but if you are interested in learning more about CSS Flexbox or CSS Grid all of Wes Bos’ material is always great.
Sign up for my mailing list and I'll send you a FREE sample from my course - Web Development with Go. The sample includes the first few chapters from the book, and over 2.5 hours of screencasts.
You will also receive emails from me about upcoming courses (including FREE ones), new blog posts, and course discounts.
Jon Calhoun is a full stack web developer who also teaches about Go, web development, algorithms, and anything programming related. He also consults for other companies who have development needs. (If you need some development work done, get in touch!)
Jon is a co-founder of EasyPost, a shipping API that many fortune 500 companies use to power their shipping infrastructure, and prior to founding EasyPost he worked at google as a software engineer.
Jon's latest progress update: Writing Course Notes
Spread the word
Did you find this page helpful? Let others know about it!
Sharing helps me continue to create both free and premium Go resources.
Want to discuss the article?
©2018 Jonathan Calhoun. All rights reserved.