Skip to content

Instantly share code, notes, and snippets.

@jsteenb2

jsteenb2/go_learning_rubric.md

Last active May 9, 2025 12:55
Show Gist options
  • Save jsteenb2/922711d67d45b18373d7754c7d511753 to your computer and use it in GitHub Desktop.
Save jsteenb2/922711d67d45b18373d7754c7d511753 to your computer and use it in GitHub Desktop.
Download ZIP
Go Learning Rubric
Raw
go_learning_rubric.md

Go Learning Rubric

This rubric will be a fanciful place for sharing really excellent content. This content is a list of high quality resources that have stood tall. However, it is not meant to be exhaustive. There is much to learn beyond here! Let's dig in.

LEGEND:

  • 🎥 - video
  • 💾 - source code
  • 📕 - book
  • 📑 - blog

Testing

Testing is ever so important. I can't stress this enough, think beyond your mocks. Think about the anatomy of your tests. Think about the lifecycle of your test code. Think about how tests become documentation. Here's some testing gems:

  1. TDD, Where Did it All Go Wrong - Ian Cooper 🎥
  2. Absolute Unit (test) - Dave Cheney 🎥
  3. Testing Without Mocks - Learn Go With Tests 📑
  4. github.com/jsteenb2/mess 💾
    • A look at a simple db test suite that is used to test across multiple implementations
    • Said another way, Write Once, Use Many testing 😏
  5. Advance Testing with Go - Mitchell Hashimoto 🎥
  6. Go Testing by Example - Russ Cox 🎥
  7. Vice test suite - Mat Ryer 💾
  8. f-tests as a Replacement for Table-Driven Tests - Aliaksandr Valialkin 📑

Structuring Code

  1. How to Inherit a Mess GopherCon 2024 Workshop - Johnny Steenbergen (me) 💾
  2. Idiomatic Go Tells a Story 🎥
  3. Preemptive Interface Anti-Pattern in Go - Jack Lindawood 📑
  4. Ways To Do (systems) Things - Peter Bourgon 🎥
  5. Code Forest vs Code Dessert - Kent Beck & Beth Andres-Beck 🎥

Concurrency

Go's concurrency is amazing to work with. Quite the paradigm shift from most other languages.

  1. Concurrency in Go - Katherine Cox-Buday 📕
  2. Concurrency is not Parellelism - Rob Pike 🎥
  3. Lexical Scanning in Go - Rob Pike 🎥
  4. Rethinking Classical Concurrency Patterns - Bryan C. Mills 🎥
  5. Go Concurrency Design Patterns - Rob Pike 🎥

Error Handling

Ohhhhh get this right, and your future selves will love you for it! Returning fmt.Errorf("allthe things: %w", err) is not the only error handling in town. You can tie into go's structural type system to create a rich domain of error handling. One that can both eliminate ambiguity in diagnosing problems as well as remove endless debug logs required for conventional debugging. There's better ways, and in go, that is to put effort into error handling :-).

  1. github.com/jsteenb2/errors 💾
  2. Go Lift - John Cinnamond (strucuting code to maximize dev ex and encapsulate correctness) 🎥
  3. Error Handling in Upspin - Rob Pike (amazing look at modeling errors in a real program) 📑

Generics

Generics are newish, and provide a ton of utility in Go. They are somewhat limited compared to some other languages, but in my experience, those same limitations stop folks from off the deep end :-).

  1. Generics Unconstrained - Roger Peppe 🎥
  2. Constraining Go type Parameter Pointers - Axel Wagner 📑
  3. Closures are the Generics of Go - Jon Bodner 🎥

Performance & Diagnostics

  1. Gophercon 2018 Performance Tuning Workshop - Dave Cheney 💾
  2. Common Go Patterns for Performance 📑
  3. Profiling Go - Russ Cox 📑
  4. An Introduction to go tool trace - Rhys Hiltner 📑
  5. GopherCon 2021: Go Profiling and Observability from Scratch - Felix Geisendörfer 🎥
  6. GopherCon 2017: An Introduction to go tool trace - Rhys Hiltner 🎥
  7. More Powerful Go Execution Traces - Michael Knyszek 📑

Systems Thinking

Systems thinking teaches how to understand the importance of the relationship of components within a system. The easiest way I can think of to go from 0 -> Hero Engineer!

  1. Systems Thinking - go beyond the JIRA ticket 📑
  2. 2 Second Lean - Paul Akers 📕

Codebases Worth Learning From

  1. github.com/matryer/vice 💾
    • Excellent testing and strong emphasis on API design
    • Not a great fit for production use case if you aren't queue agnostic or need control of message ACKs
  2. github.com/benbjohnson/bolt 💾
    • Emphasis on simple, beautiful stuff. Excellent testing, attention to details in the public API
    • Its not everyday you find a database implementation that is grokkable :-D
  3. github.com/influxdata/[email protected]
    • Builds on the excellence of bolt's design here. Check out the kv, bolt, inmem and their testing :-D
  4. github.com/WasabiAiR/stow 💾
    • Again, excellent testing and strong emphasis on API design
    • Clarity, ease of contribution
    • Not a great fit for produciton if you are not object storage agnostic, come with limitations
  5. github.com/CrowdStrike/foundry-fn-go 💾
    • A look at API design across numerous functional boundaries, both internal and external facing
    • Comparing it with an older version is helpful, shows the point A -> point B transition and motivation
    • Disclaimer: I was the primary contributor 😅

Gotchas

Go is not without its warts. The following walks through a number of different go gotchas.

  1. Gotchas 💾
  2. Stump the Gopher Go Quiz - Chris Pahl 📑

Career Growth

At the end of the day, we work as engineers or programmers. It's probably for the best that we understand how to function in a professional environment :-D.

  1. Real 10x Programmers Are SLOW To Write Code - Jayme Edwards 🎥
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment