Learning Go in 2025

Learning to program or learning a new language can be daunting. In this post we are going to discuss a few tips and resources that can make learning Go easier in 2025.

To start, I’m going to break down what I think are the three main phases for learning Go. After that I’ll start to discuss the caveats of each phase and discuss some potential resources to check out when you are at that stage of the learning process.

1. Learn the basics

The first step in learning Go is to become comfortable enough with the basics so that you can progress to practice problems and exercises. You should aim to learn how to write a simple program from scratch that uses things like a if/else statement, for loops, custom functions, and a package import or two.

You goal is NOT to memorize every type in the language, or to try to become an expert in any other way. It doesn’t matter if your code is idiomatic or not at this point. It doesn’t matter if you perfectly understand what a slice is and how it works. All of that will come with time and practice.

Your goal here is to learn just enough so that you can start practicing and learning from that practice, as that is where a majority of your learning will come from early on. It is much easier to understand what a map is and why you would need one when you are applying it in actual code.

2. Learn to solve problems & practice coding

Once you have the basics down, your next goal is to learn to solve problems. To do this, you will often need to learn to do things you have never done before. For instance, someone might ask you to create a URL shortener like bit.ly, and you might not know exactly how to do it. Your goal is to get to a point where you are comfortable searching the docs, the internet, and wherever else to figure out how to solve the problem.

This is where a majority of your learning will take place. Many people can learn the basics of a programming language, but will fail to push themselves past that point. To become a proficient developer, you will need to learn to solve problems that you have never encountered before. The best way to do this is by practicing.

Another way to think of this is the “Learn to Learn” step. Your goal here isn’t a specific set of knowledge, but rather learning how to figure out unknowns so that you can tackle any future problems. To this end, personal projects also work well, but they will ideally be scoped small enough that they don’t become overwhelming, as this can cause people to quit or give up prematurely.

3. Dive deeper into what you enjoy

Once you have learned how to learn, the final step is to pick the type of programming you want to do or the career path you want to follow and to focus on resources specific to that goal.

If you want to learn how to test code, go find resources on this and spend time writing tests for both your new code and some existing programs. If you want to learn how web applications work, find resources on those and dive into them. If you want to build games, CLIs, or really anything, spend time diving deeper into those topics.

This is also the time to get involved in bigger personal projects. This will help teach how to break a large project into more manageable tasks, but it won’t be happening so early in the learning path that it makes you feel inadequate. It will simply be another challenge to tackle and learn from.

Now that we have a rough idea of what the three major steps are, let’s look at resources that fall into each step.

Learn the basics

There are roughly two categories of people in this stage of learning:

1. People who want to learn how to program using Go
2. Existing developers who want to transition to Go from another language

For the first group - people who want to learn how to program using Go - I typically recommend resources that go into a bit more depth and detail, as you will often be presented with concepts that are completely foreign to you. For instance, most people do not know what a function is prior to learning to program, so it can be beneficial to read more details about what a function is, why it can be useful, and what they look like in Go. Meanwhile, someone with existing programming experience might only need to see examples of how to declare a function in Go to proceed.

The first resource I typically recommend is ​GolangBot’s tutorial series​. It isn’t the most comprehensive or in-depth course in the world, but it is free so this makes it a great starting point for someone who is on the fence and wants to dip their does in.

Another resource I’ll frequently recommend is ​Todd McLeod’s “Learn How to Code” course on Udemy​. What makes this course stand out is that it was specifically designed as a university course for beginners with no prior programming experience. Most other Go books and tutorials tend to be written primarily for people with prior programming experience. (Note: Todd’s course is frequently on sale for $11 on Udemy if you don’t mind waiting for a sale.)

After these two resources most new developers are ready to move on to the next step.

For the second group - developers with prior experience - the resources they use to learn the basics of Go are typically going to be more to the point. They will quickly illustrate various aspects of Go using code samples then move on without too much extra fluff. They often don’t need to have as many exercises and examples, as developers can typically see a code sample and relate it to some preexisting knowledge.

The primary resource I will typically recommend for developers switching to Go is ​A Tour of Go​. It was created by the Go team, and is a quick introduction to most concepts in Go. It doesn’t go into enough details for brand new programmers, but if you have used another programming language a reasonable amount it will be a great jumpstart into the language and will often be all you need to get comfortable enough to write and read basic Go programs.

From there an experienced developer probably knows enough to start writing a few basic programs and can then proceed to the next set of resources.

Learn to solve problems & practice with Go!

When learning to code, most of your learning will come from working through problems, writing Go code, and reviewing how others solve similar problems. In the previous phase of learning you started to get the basics of Go types, what slices and maps are, etc, but you won’t really understand them until you start using them in code. To that end, a lot of what you will be doing in this phase is using resources that present you with practice problems, or using resource to help you come up with and complete practice programs.

The first resource for this is ​Go by Example​. This is a list of annotated example programs, and while I don’t find them particularly great to read one-by-one, they can be great for learning how to solve common problems. For instance, you might decide to practice by creating a program that opens a file, counts the number of times a word appears in the file, then prints it out to the screen. Go by example is a great tool for helping with this type of practice.

​Gophercises​ is a free video course that I created for this phase of learning as well. One of the challenges that many developers encounter when coming up with practice problems is unknowingly picking something too hard or too easy. In this course I present a variety of exercises, each tailored to teach specific skills and to be achievable without an incredibly large time investment. To get the most out of the course, I highly recommend trying to code each exercise on your own. This can occur before or after you watch me complete the exercise in the video, but doing the actual problem on your own is vital to learning.

(Note: This course will be getting an update in 2025, but the content and lessons taught here are still applicable and worth checking out prior to the update.)

Another commonly suggested resource is ​Effective Go​. Again, this is created by the Go team, but rather than being an introduction to the language, it serves more as a set of tips and advice for writing better Go code. I wouldn’t start here, but after writing a decent bit of Go code it can be a great resource to start learning how to write more idiomatic Go code.

​Learn Go with Tests​ is another popular resource worth checking out. This will start introducing you to writing tests for your Go code while also reinforcing much of what you are learning about the language itself.

Next is a shameless plug for my own course - ​Web Development with Go​. In this course we work towards building a complete web application with Go, but more importantly, the entire course is designed around teaching not only how to build web apps, but how to be a better Go developer. Rather than presenting you with the final code and code structure, we instead work from scratch and discuss the reasoning for every coding decision we make. This discussion of my thought process, then the resulting code refactors and updates are all incredibly valuable for anyone learning to build larger applications. Then once you complete the course, there is a ton of knowledge to be gained by using it as a guide while you build your own web application from scratch.

Code reviews are also incredibly helpful toward the middle and end of this phase, but I leave these at the end of the list as not everyone has access to someone who can provide good feedback as they work on a project. Just be sure to take advantage of it if you do have access!

Dive deeper into what you enjoy

Hopefully by this point you have a stronger understanding of Go and feel comfortable solving problems, even if you need to do a little research to make it happen. You will still want to continue learning from building things, reviewing code with others, and everything you did in the last phase, but you likely want to start tackling larger projects and diving deeper into more complex topics.

For instance, if you want to join a company doing enterprise software, you likely would benefit from learning topics like domain-driven design, so you might use a resource like ​Matt Boyle’s Domain-Driven Design with Golang​. Or if you want to learn how to test complex software, you can start seeking out talks, tutorials, or even a course like ​Test with Go​ to learn more about the topic. You might also want to learn about Docker, concurrency, event-driven architecture, and a dozen other topics I am forgetting about as well.

Whatever it is you want to learn or focus on, I suggest picking one topic at a time and slowly working through resources, all while practicing by applying what you learn in code you are writing.

At this stage it is hard to point out specific resources, since what everyone needs to learn will vary, but the key thing to focus on is getting comfortable with bigger projects, and starting to focus on more advanced topics in the area that you will need for the work you want to do.

What about <insert course/book here>?

There are a ton of great Go resources that I haven’t included here. There are hundreds of them out there, all created by passionate Gophers. If a resource you love isn’t here, it isn’t out of malice, but rather it is a result of me trying to keep this list fairly short.

Rather than flooding you with a large number of resources and introducing decision fatigue, I instead wanted to provide what I felt was a good learning path to focus on along with a limited number of resources. I felt this would create a nice path to follow without someone needing to worry if they picked the right resource or not. In short, you should just be able to go through the list and make great progress while learning Go.

If you would like a more comprehensive list of resources to check out, Byte Size Go has a pretty nice ​compilation of resources​ which would be a good starting point. I also have additional resources in my Guide to Learning Go that I wrote, including advice on fixing bugs and getting help.