Learning Go in 2024; From Beginner to Senior
Tags: learning, go
Published: 2024-03-31 18:36:56

---
title: Learning Go in 2024; From Beginner to Senior
published: true
description: 
tags: [Learning, Go]
cover_image: https://d31ezp3r8jwmks.cloudfront.net/c030rvxwdm6nxgbkyfk4asham4pt
# Use a ratio of 100:42 for best results.
# published_at: 2024-03-28 20:21 +0000
---

> **_NOTE:_** 
> Save here for study later... Yes, I copy this because it's important... sorry......


## By: Matt Boyle1

I have therefore split each of the levels into these categories. It’s impossible for this to be conclusive, but feel free to leave comments with other recommendations. I’ll check them out and add them if I think they are great.

* * *

## Just Starting Out - The Beginner Gopher 

![Go experience](https://s3.us-west-2.amazonaws.com/content.podia.com/nuf6o38ndtopfv7acwnl4v1xsbj9)

If you have minimal/no Go experience start here. If you have built at least one Go application that has some business logic and it runs, you can probably graduate to the next section.

Books/Blogs
-----------

In this section some of the “blogs” could probably be in courses, but since they are not video I included them here. 

*   [A Tour of Go](https://go.dev/tour/welcome/1) \[FREE\]- This is created by the Go team. It starts with Hello world and is an interactive tutorial that will teach you the basics of Golang. 
    
*   [Go By Example](https://gobyexample.com/) \[FREE\] - Similar to A tour of Go but it dives a little deeper and covers some slightly more “advanced” topics.
    
*   [Effective Go](https://go.dev/doc/effective_go) \[FREE\]- Another official resource. Less interactive than the other two but the depth is amazing. If you work through this, you’ll be ready to write pretty much any Go application you want.
    
*   [The Go Programming Language](https://www.gopl.io/) \[PAID\] - This book was originally published in 2015 but has held up to the test of time really well. I still hear great reviews from folks starting out with this one.
    
*   [Introducing Go](https://www.oreilly.com/library/view/introducing-go/9781491941997/) \[PAID\] - Same as above, this book came out in 2016 but continues to get good reviews from those who are starting out. 
    
*   [Let’s Go!](https://lets-go.alexedwards.net/) \[PAID\]- This book gets rave reviews from folks just starting out. I bought a copy, and I can see why.
    
*   [Golang Tutorial Series](https://golangbot.com/learn-golang-series/) \[FREE\] - Old but still has a lot of great content.
    
*   [For the love of Go](https://bitfieldconsulting.com/books/love) \[PAID\] - John Arundel has tons of amazing Go content and books, but this one is an amazing introduction that is written in a really nice, casual style.
    

Video Courses/Conference Talks
------------------------------

*   [Learn How To Code: Google's Go (golang) Programming Language](https://www.udemy.com/course/learn-how-to-code/?couponCode=ST15MT31224) with Todd Mcleod \[PAID\] - I fall into the category of folks who like to learn via video courses. I learned Go from Todd many years ago and as you can see from the amazing reviews, Todd continues to be a great teacher to many people. 
    
*   [Learn Go](https://www.codecademy.com/learn/learn-go) \[FREE\] - This course has great reviews and was built in partnership with Google. 
    
*   [Why I use Golang in 2024](https://www.youtube.com/watch?v=6gwF8mG3UUY) \[FREE\] - It's always nice to hear the why from folks with experience, and I think this video explains it in a fun way. 
    

What Should I Build?
--------------------

At this stage, the most important thing you can do is just get familiar with the syntax, get Go working on your machine and find an IDE you like. 

As a project, I recommend building something with the following requirements:

*   Is a CLI app.
    
*   When you run your program, it asks you for the date of birth. 
    
*   The program calculates your age and prints it back to your console.
    
*   Do not use any third party libraries, use only the Go Standard library.
    

This might sound simple, but if you can complete this project without support then:

*   You have Go setup on your machine correctly, including setting up your IDE.
    
*   You have managed to navigate the [standard library documentation](https://pkg.go.dev/std) to figure out how to create a CLI and read user input. 
    
*   You have got `go run` working successfully. 
    

_If you're looking for further things to build, check out_ [_Coding Challenges_](https://codingchallenges.fyi/)_. At this level, the_ [_WC task_](https://codingchallenges.fyi/challenges/challenge-wc) _seems a good one._

Listen
------

*   [Go For Beginners](https://changelog.com/gotime/239) \[FREE\] - Gotime is the most popular Go podcast, and for good reason. There is some great content here if you want to learn a little more about what’s going on in the go community whilst you walk or workout.
    
*   [Books that teach Go](https://changelog.com/gotime/197) \[FREE\] - Some more recommendations here. Also talks about writing a book too if that’s something you aspire for :)  
    

* * *

If you're enjoying this blog, be sure to subscribe to the byteSizeGo newsletter to be the first to get great content like this:

[subscribe](https://bytesizego.com/subscribe)

* * *

## A Little Experience - The Junior Gopher 

![The Junior Gopher](https://s3.us-west-2.amazonaws.com/content.podia.com/a895omstirhnlf0ot60csobu0x0c)

If you finished the CLI exercise mentioned above, then you’re ready to jump into the content below to take yourself to the next level!  By the end of this section you should have a deeper understanding of Go, have built quite a few applications and be ready to start applying for jobs.

Books/Blogs
-----------

*   [Domain-Driven Design with Golang](https://www.packtpub.com/product/domain-driven-design-with-golang/9781804613450) \[PAID, written by me\] - As you start to write larger Go projects, you’re going to start wondering how to organize your projects. DDD is another acronym you will see come up often. This book is a gentle introduction to the concepts, and you don’t need any prior knowledge. In the second half of the book we also build two projects together.
    
*   [100 Go Mistakes and how to avoid them](https://www.manning.com/books/100-go-mistakes-and-how-to-avoid-them) \[PAID\] - This book really does help you avoid footguns. This is a book you may need to revisit at this level, as some of the content might seem a little advanced. However, I find it's good to skim over and have the patterns and concepts in your mind, as there have been a couple of times I have made a mistake and then realized it was called out in this book; I then grab it and look up the solution. 
    
*   [Let’s Go Further](https://lets-go-further.alexedwards.net/) \[PAID\] - A follow up to Let’s go. Again, this one gets excellent reviews from folks who have read it. This is focused on API design specifically so keep that in mind if that is not the reason you are learning Go.
    
*   [Learn Data Structures and Algorithms with Go](https://www.packtpub.com/product/learn-data-structures-and-algorithms-with-golang/9781789618501) \[PAID\] - Now you are familiar with the Go syntax, getting familiar with data structures will pay dividends. Go doesn’t have the equivalent to Java collections and you might be surprised at how many data structures and algorithms you have to build somewhat from scratch.
    
*   [12 Factor Application with Docker & Go](https://leanpub.com/12fa-docker-golang) \[PAID\] - If you are going to be using Go for application development, it is important to understand how it fits into the container ecosystem, and I like the way this book approaches it. 
    
*   [How I keep myself alive with Go](https://www.bytesizego.com/blog/keeping-alive-with-go) \[FREE, written by me\] - I got the pleasure of giving this blog as a keynote at gophercon Singapore. This post is my most popular and went viral. It's an interesting insight into how you can use Go to solve practical problems.   
    

Video Courses/Conference Talks
------------------------------

*   [Gophercises](https://gophercises.com/) \[FREE\] - Gophercises are often shared as one of the best free resources there is. They feel like you are pairing with Jon as he builds projects, and you can follow a long at home. I’d recommend completing them alongside him, and then extending the project to add a little functionality yourself. 
    
*   [Web Development with Go](https://www.usegolang.com/) \[PAID\] - Jon Calhoun has been teaching Go since the early days. He worked at Google and now hosts the Go Time podcast. This course is excellent and very comprehensive. I gave a couple of copies away in my [Go Twitter Community](https://twitter.com/i/communities/1685641800449462272) and feedback was incredibly positive. 
    
*   [Learn Go With Tests](https://quii.gitbook.io/learn-go-with-tests/) \[FREE\] - You’ll hear mention testing a lot as you learn more and more Go, and hear the phrase TDD thrown around. This amazing book will help you learn what it is, how to do it and teach you more Go as you do so. I highly recommend this one. 
    
*   [When to use Generics](https://go.dev/blog/when-generics) \[FREE\] - As you continue your Go journey, you’re going to hear about generics a lot, because they are a hot topic. I have my own opinions on their usage, but in this video the Go team themselves share best practises on 
    
*   [Structured Logging in the standard library](https://www.youtube.com/watch?v=8rnI2xLrdeM&list=PLDWZ5uzn69eyvx0WUpGoOJ6MPI23TFbgC&index=4) \[FREE\] - I teach structured logging in my debugging course, and I think its one of the earliest optimizations you can make to improve developer experience. This video is an amazing introduction on how you can do it using the new tools in the standard library.
    
*   [What we got wrong, what we got right in Go](https://www.youtube.com/watch?v=yE5Tpp2BSGw) \[ FREE\] - Now you know a little more about Go, you should watch this retrospective by Rob Pike (who is in the Go team at Google) on some of the decisions they made whilst developing the language. Its incredibly insightful and interesting. 
    

What Should I Build?
--------------------

###  Exchange rate server

**Requirements**

*   Write a http server with an endpoint that takes a currency pair. For example /exchange/GBP/USD. For that currency pair, it should list today’s exchange rate, the exchange rate for the past 7 days and whether today is a good day to buy. 
    
*   Whether it is a good day to buy or not can be super naive, I recommend just averaging the last 7 days and seeing if it is lower than today. However, this is flexible. 
    
*   Make sure the logic is well tested.
    

**Commentary** 

The GO team provide guidance on how to organize a project: [https://go.dev/doc/modules/layout](https://go.dev/doc/modules/layout) and here is a post by the legendary Dave Cheney on how to write Table tests: [https://dave.cheney.net/2019/05/07/prefer-table-driven-tests](https://dave.cheney.net/2019/05/07/prefer-table-driven-tests).

Here’s a great post on creating a go module: [https://go.dev/doc/tutorial/create-module](https://go.dev/doc/tutorial/create-module)

I believe with all this, you’ll be in a good spot to have a first pass at this. Do not worry about it being beautiful and do not worry if you find it hard, all that means is you are learning 🙂. Brute forcing an ugly solution at this point is totally ok. 

_If you're looking for further things to build, check out_ [_Coding Challenges_](https://codingchallenges.fyi/)_. At this level,_ [_building your own Spotify Client_](https://codingchallenges.fyi/challenges/challenge-spotify) _seems a good task._

Listen
------

*   [Project Structure & Package naming](https://gopodcast.dev/episodes/002-project-structure-package-name) - Great discussion here about something that will come up often as you navigate Go.
    
*   [Error Handling In Go](https://gopodcast.dev/episodes/001-error-handling-in-go) - Error handling is a really important concept in Go, and this podcast episode gives a good discussion on approach. 
    
*   [Domain-Driven Design with Go](https://changelog.com/gotime/273) - Podcast discussion around DDD starring me 🙂
    
*   [The Pain of dependency management](https://changelog.com/gotime/242) \- Go has a difficult history with dependency management and this podcast episode is a good summary of where we have come from and the issues still outstanding.
    

## Some Experience - The Mid-level Gopher  

If you have a few greenfield projects under your belt, and have also made meaningful changes to existing Go Code bases that you didn’t write, then you’re a mid-level gopher. Leveling up from here is digging into some of the more advanced patterns and tools that Go has to offer.

Books/Blogs
-----------

*   [Concurrency in Go](https://www.oreilly.com/library/view/concurrency-in-go/9781491941294/) \[PAID\] - Concurrency is really interesting in Go, but can be a little difficult to get your head around. This book does a good job of explaining the primitives. 
    
*   [A Tour of Go, Concurrency](https://go.dev/tour/concurrency/11) \[FREE\] - Continuing the concurrency theme, the tour of Go is really helpful and links out to a bunch of other good resources too. 
    
*   [Event-Driven Architecture in Golang](https://www.packtpub.com/product/event-driven-architecture-in-golang/9781803238012) \[PAID\] - As you are progressing with your career, it's important to understand both code and architecture. This book does a great job of helping you understand both the Event-Driven Architecture Pattern and how to apply it to Go.
    
*   [More Powerful Go Execution Traces](https://go.dev/blog/execution-traces-2024) \[FREE\] - This recent addition to the Go blog discusses some performance tuning changes they have made to Go that you can make use of. You can combine that with [this](https://go.dev/blog/pgo) post (also from the Go team) to learn a lot about how to optimize your application. 
    
*   [Crash Course on Go interfaces](https://www.calhoun.io/crash-course-on-go-interfaces/) \[FREE\] - Interfaces are implemented in an interesting way in Go with them being implicit. This blog will get you started with everything you need to know.
    
*   [Building Modern CLI applications in Go](https://www.amazon.com/Building-Modern-CLI-Applications-next-level/dp/1804611654) \[PAID\] - A lot of Go content is focused on building APIs, but as you progress in your career, you’ll find more and more you want to build other types of applications, with CLIs being incredibly valuable and often overlooked. In this book, Marian teaches you how to make CLI applications in GO but always zones in on the user experience.
    

What Should I Build?
--------------------

Develop a tool that scrapes information from websites and presents it in a useful format. This could involve parsing HTML, handling pagination, and storing scraped data. You should store the scraped data in a database and send an email to yourself whenever something interesting is discovered.

Scraping is an incredibly challenging thing to do, as one change to the html of a site can break your scraper; having modular code with good visibility is therefore a must. 

One use case for this is to check a site every day to see if a video game you are interested in is on sale. 

_If you're looking for further things to build, check out_ [_Coding Challenges_](https://codingchallenges.fyi/)_. At this level,_ [_building your own Memcached_](https://codingchallenges.fyi/challenges/challenge-memcached) _seems a good task._

Video Courses/Conference Talks
------------------------------

*   [The Ultimate Guide to Debugging with Go](https://www.bytesizego.com/the-ultimate-guide-to-debugging-with-go) \[PAID, created by me\] - I noticed a real shortage of content for mid-level Gophers, and I believe debugging is the most important skill that you do not get taught. By the end of this course you’ll be a master at debugging both locally and in production. We cover beginner and advanced topics.
    
*   [Ultimate Go Bundle](https://www.ardanlabs.com/training/individual-on-demand/ultimate-go-bundle/) \[PAID\] - Ardan Labs offer amazing Go training, and you can get access to 7 of their courses with one subscription here. It's expensive, but it's > 100 hours of content and they do offer scholarships too.
    
*   [How Go Programs keep working](https://www.youtube.com/watch?v=v24wrd3RwGo) \[FREE\] - The Go Compatibility promise is one of its most highly respected features. In this video Rss Cox explains how that is actually possible. 
    
*   [Build a Google Analytics in Go](https://dominicstpierre.com/product/build-a-google-analytics-in-go) \[PAID\] - Dom’s courses are highly practical. By the end of this course you have built something somewhat complex and have a new portfolio project too!
    
*   [Go Concurrency Patterns: Pipelines and cancellation](https://go.dev/blog/pipelines) \[FREE\] - This blog gives a very concrete walkthrough of some patterns for concurrency that I have used numerous times throughout my career. Highly recommended you get familiar with it!
    

Listen
------

*   [Intro to GRPC](https://share.transistor.fm/s/86b8d65c) \[FREE\] - As you get more comfortable with the core fundamentals of Go, it is time to branch out and learn more about architecture. gRPC is a great way to start and it has first class support in Go. 
    
*   [Foundations of Go Performance](https://changelog.com/gotime/304) \[FREE\] - In the first of a multi-part series, Ian & Johnny are joined by Miriah Peterson & Bryan Boreham to peel back the first layer of the things that matter when it comes to the performance of your Go programs.
    
*   [Event-Driven Systems & Architecture](https://changelog.com/gotime/297) \[FREE\] - Event-driven systems may not be the go-to solution for everyone because of the challenges they can add. While the system reacting to events published in other parts of the system seem elegant, some of the complexities they bring can be challenging. However, they do offer durability, autonomy & flexibility.
    
    * * *
    

## A lot of Experience - The Senior Gopher  

![The Senior Gopher](https://s3.us-west-2.amazonaws.com/content.podia.com/j6tvaxvy8a0yrtc5kr2gxq3fte03)

At this point you have shipped a ton of Go to production and find it pretty easy to implement complex systems. You have maintained Go systems for a while and made improvements to Go code written by others.

At this level, you know how to write idiomatic Go and the biggest opportunity for growth is to learn more about architecture and technologies that can complement your Go skills.

Books/Blogs
-----------

*   [How to Build a real-time event system in Go](https://www.freecodecamp.org/news/build-a-real-time-notification-system-with-go-and-kafka/) \[FREE\] - As systems get bigger, moving to an event-driven system is a common approach. Getting familiar with the tools and patterns used is a great idea at this stage in your career.
    
*   [Keep the Monolith, split the workload](https://incident.io/blog/monolith) \[FREE\] - This blog from [Incident.io](http://Incident.io) challenges a lot of the narrative about moving to small domain scoped microservices and as you progress in your career i think it's important to be open to challenging your way of thinking. I love posts like this.
    
*   [How to use websockets in Go - A comprehensive guide](https://yalantis.com/blog/how-to-build-websockets-in-go/) \[FREE\] - continuing our theme of learning more about different architecture patterns when applied to Go.
    
*   [The Go memory model](https://go.dev/ref/mem) \[FREE\] - As you start to build bigger systems, performance is going to matter. Understanding Go’s memory model will really help you to figure out how to do this. 
    
*   [Kubernetes memory limits in Go](https://www.ardanlabs.com/blog/2024/02/kubernetes-memory-limits-go.html) \[FREE\] - This is pretty niche, but I think the blog does a great job of setting the scene even if you do not use Kubernetes. 
    
*   [Explore Go Cryptopgraphy](https://bitfieldconsulting.com/books/crypto) \[PAID\]  - In this book John digs into how crypto works in Go which we arguably should all know more about. 
    

What Should I Build?
--------------------

 Build a framework that simplifies the development of distributed systems in Go. This could include features like service discovery, load balancing, fault tolerance, and consistent hashing. This project will deepen your understanding of network protocols, concurrency models, and the complexities of distributed systems.

You can take inspiration from [go-kit](https://github.com/go-kit/kit)

Video Courses/Conference Talks
------------------------------

*   [GRPC Microservices with Mongo, JWT auth and kubernetes](https://www.youtube.com/watch?v=f6KG5eqOPFw) \[FREE\]  - I don’t necessarily agree with all of the approaches taken in this course, but I am glad folks are creating content to get people thinning about and familiar with different databases and auth. This will give you a great foundation of a bunch of different technologies.
    
*   [Building microservices with Go](https://www.youtube.com/playlist?list=PLmD8u-IFdreyh6EUfevBcbiuCKzFk0EW_) \[FREE\]  - Same as above. This course is pretty old but still valuable nonetheless. The more approaches you see to building things the more opinions you will get yourself.
    
*   [Memory Management in Go: The good, the bad and the ugly](https://www.youtube.com/watch?v=SKenR18NM04) \[FREE\] - In this session, Liam delves into the crucial topic of memory management, providing a comprehensive overview of what it is, why it matters, and how to harness its power to write highly performant and cost-efficient code. 
    
*    [How Cloudflare Controls it's Network Using Go](https://www.youtube.com/watch?v=op14_lAifQ4) \[FREE\] -  A practical use of Go; Quicksilver is a distributed key value store that Cloduflare uses to power its networks. 
    
*   [How to Build a Distributed system, and should you?](https://www.youtube.com/watch?v=29SSAht65ZI&list=PL2ntRZ1ySWBfiSJSt-zPRbVSMDfK0EwQC&index=7) \[FREE\] - This is my favorite type of talk; it's experiential and gives you some great advice.
    

Listen
------

*   [Jumping into existing codebases](https://changelog.com/gotime/307) \[FREE\] - Jumping into a codebase you’re unfamiliar with can be challenging, but is important to get good at. This episode of go time covers off some different methods of doing that.
    
*   [Creating Art with Go](https://changelog.com/gotime/305) \[FREE\] - This is just a straight up interesting use case for Go.
    
*   [All About Kafka](https://changelog.com/gotime/299) \[FREE, features me\] - In this episode I join Kris & Jon to discuss Kafka. During our discussion we cover topics like what problems Kafka helps solve, when a company should start considering Kafka, how throwing tech like Kafka at a problem won’t fix everything if there are underlying issues, complexities of using Kafka, managing payload schemas, and more.
    

* * *

## Keeping up to Date 

![Keeping up to Date](https://s3.us-west-2.amazonaws.com/content.podia.com/icpjx58fkvxvh8jkd8a7wvop46na)

Software Engineering, both in Go and in any other language, is a lifelong commitment to learning. Its important that you dedicate time to ensure you are always keeping up to date. Below are some of the ways you can do that.

*   [Subscribe to byteSizeGo](https://www.bytesizego.com/subscribe) \[FREE\] - I share great Go content and discount codes with my subscribers. If you only do one thing, make sure you subscribe here!
    
*   [Go 1.22 in 22 minutes](https://www.bytesizego.com/what-s-new-in-go-1-22) \[FREE\] - A free course I put together on all the important changes added to go in Go 1.22.
    
*   [Go Time](http://gotime.fm/) \[FREE\] - An amazing Go podcast that covers a wide variety of topics with a wide variety of people from the Go community. Ideal to listen to whilst walking or at the gym.
    
*   [The Go Podcast](https://gopodcast.dev/) \[FREE\] - Same as above, but hosted exclusively by Dom. He’s started interviewing guests (including me) which I think is making the show even better!
    
*   [Golang weekly](https://golangweekly.com/) \[FREE\] - I have been subscribed to this newsletter for years and recommend it highly; it aggregates all the best Go content of the week. Hopefully you found this blog article from there!
    
*   [Applied Go](https://appliedgo.net/subscribe/) \[FREE\] - I have only discovered this newsletter recently but have been really happy with the content so far. Highly recommend subscribing to this too.
    

## Wrapping up

It took me a long time to compile this list so I hope you found it helpful. Let me know in the comments if it's helpful and if there is any other content I should review and add!

[Source](https://www.bytesizego.com/blog/learning-golang-2024?ref=dailydev)