Read the Go standard library, especially the parts written by Russ Cox. The parts written by Griesemer are less pleasant, no offense to him
But some of Go's language decisions only become clear once you've written a lot of Go
For example, the "var name = expr" declaration form seems unnecessary in light of the short ":=" form but it is in the language to allow indented declaration blocks like this (where some variables get an initial value and some get just a type):
var (
text []byte
last int
more = true
)
...
I really enjoyed reading the upspin codebase. I thought it was really a clean design and clean code. Some of the early go team members were working on it including andrew gerrand and rob pike. I think its a bit of an experiment on how one might design a content sharing system if you were to start from the ground up and not on the current web standards. I particularly like how they work authentication and authorization into the model. I had a few experimental upspin services I wanted to write but never got around to.
Another great read for learning go that covers the more traditional challenges of standing up a basic web service with user accounts, testing, metrics, etc. is https://github.com/benbjohnson/wtf and the accompanying blog posts that cover how to structure such an application and why.
Hey mate. I built, recently, a service that tracks all repositories mentioned on HackerNews and Reddit. Based on that data you can see which are the most popular or talked about repos per language. I guess that can help you. e.g. https://www.libhunt.com/lang/go
A lot of people are saying to read the stdlib, but the stdlib has a lot of objectively bad code in it. Some of it is necessary due to the nature of a standard library - you have extra concerns about dependencies to ensure people don't have to include the entire stdlib in every binary. Some of it is stuff they hacked together when they were still designing the language, and that initial code still works fine so no need to update it.
I think the source code for pkg.go.dev is actually a treasure trove of good ideas and design patterns, especially if you are trying to make a small to mdedium sized web app (which, lets be real, is almost all web apps anyone will ever make). https://github.com/golang/pkgsite
I also suggest reading: stdlib, projects by Rob Pike (Upspin), Andrew Gerrand, Brad Fitzpatrick, Dmitry Vyukov, Jaana Dogan, Jonathan Amsterdam.
Please avoid: Kubernetes, AWS code.
As a rule of thumb - less imports is better.
I consider rclone one of my most used tools for managing data, and personally think it's reasonably well-structured: https://github.com/rclone/rclone
I agree with the other commenters that stdlib is excellent for delving deep into the language.
You can check out the Pirsch Analytics core [0]. I'm the maintainer and can answer all your questions :) It probably contains most features you'll use when programming in Go. Take a look at the tracker.go for a concurrent collector. It also has a lot of parsing, a data model, database, http, public API, ... and UI is not required while learning Go I suppose.
I learned a lot from reading the Perkeep [1] codebase (formerly Calimstore). One of its core developers is Brad Fitzpatrick (former Golang team member) so you can be fairly confident it’s idiomatic Go.
I think LXD would be a good repo to look at. You would see examples of REST daemons, clustering, database access, auth, containers, etc. https://github.com/lxc/lxd
It's no substitute for reading the code for a useful bit of software, but I always like to head over to https://learnxinyminutes.com/ to check out the short code examples/overviews to get a feel for a language.
I believe the best of the best use of Golang is being done by Dgraph.
They are the The world’s most advanced native GraphQL database with a graph backend.
Checkout their GitHub repo.
I recommend the Mattermost server:
https://github.com/mattermost/mattermost-server
And I disagree with those that say stdlib is the best way of looking at the best Go code for two reasons:
1. A lot of times stdlib code is restricted to use only backward compatible code with old API contracts, some parts are neat but others are unwieldy. It's a hit or miss.
2. Library code is different to application code. You can't get as much variety in style, abstractions, design patterns in stdlib as you can in a real world application.
I reckon it's important to read to get a whiff of succinct Go code, very good at learning protocols (like OAuth, Http etc) if you're interested, but won't be hugely helpful in building a CRUD app.
I really enjoyed google's https://github.com/golang/groupcache. Learned both about the language, and quality network application design, in a small package.
I haven't seen anyone recommend net/http yet, but that is the library that was recommended to me to read to get a sense for modern, idiomatic go.
I started trying to implement a basic example best practices (yet full featured, as a starting point for my own projects) go http server.
This is my result:
Not a project per-se but a lot of small example projects: https://github.com/inancgumus
thread from 2017: https://news.ycombinator.com/item?id=14462125
The easiest way to learn golang is to sign up on HackerRank and try out their exercises. You can do it in-browser, so no need to even install the toolchain. You'll learn faster by doing and reading in parallel.
To see examples of good source code just click thru the function names when searching the documentation. E.g. https://golang.org/pkg/net/http/#NewRequest They link directly to the source code, and the standard library is extremely well commented.
The best Go source code is the stdlib. When you read stdlib code, you can be confident that nothing is there by accident. Every decision was made for a reason. When you're learning, that's invaluable, because it means you can "dig" anywhere and be rewarded for it, whereas "digging" into most codebases will often be a waste of time.
Also, I would advise actively avoiding the big names you have heard of. A lot of products are successful despite having garbage code. And even more of them are successful despite having only decent code, full of stuff not worth emulating.
Try to identify people who have a lot of experience and a strong command of the language, then look at their most recent projects.