Go blogs

• Advanced Go Concurrency Patterns ( go.dev )
• All your comparable types ( go.dev )
• Code coverage for Go integration tests ( go.dev )
• Contexts and structs ( go.dev )
• Defer, Panic, and Recover ( go.dev )
• Effective Go ( go.dev )
• Fuzzing is Beta Ready ( go.dev )
• Go Concurrency Patterns: Context ( go.dev )
• Go Concurrency Patterns: Pipelines and cancellation ( go.dev )
• Go Concurrency Patterns: Timing out, moving on ( go.dev )
• Go Wiki: Use a sync.Mutex or a channel? ( go.dev/wiki )
• How to Write Go Code ( go.dev )
• More predictable benchmarking with testing.B.Loop ( go.dev )
• New unique package ( go.dev )
• Introducing the Go Race Detector ( go.dev )
• Profiling Go Programs ( go.dev )
• Slices intro ( go.dev )
• Telemetry in Go 1.23 and beyond ( go.dev )
• Vulnerability Management for Go ( go.dev )
• What’s in an (Alias) Name? ( go.dev )
• Writing Web Applications ( go.dev )

Blogs

• Don’t return err in Go ( akavel.com )
• Go features by version ( antonz.org )
• For Loops and More in Go ( ardanlabs.com )
• How Go Tests “go test” ( atlasgo.io )
• Encrypting with AES ( bitfieldconsulting.com )
• Go Generics Improvements for Maps and Slices ( bprecheur.orgla )
• Are Golang slices dynamic arrays or fat pointers? ( build-your-own.org )
• A Brief History of Dependency Management in Go ( bytesizego.com )
• Learning Go in 2024; From Beginner to Senior ( bytesizego.com )
• Crash Course on Go Generics ( calhoun.io )
• Crash Course on Go Interfaces ( calhoun.io )
• Does Go’s range Copy a Slice Before Iterating Over It? ( calhoun.io )
• How to test with Go ( calhoun.io )
• How to use slice capacity and length in Go ( calhoun.io )
• What is a Closure? ( calhoun.io )
• 5 Useful Ways to Use Closures in Go ( calhoun.io )
• 6 Tips for Using Strings in Go ( calhoun.io )
• A pragmatic guide to Go module updates ( carlosbecker.com )
• Reclaiming CPU for free with Go’s Profile Guided Optimization ( cloudflare.com )
• How to write bemchmarks in Go( dave.cheney.net )
• 8 Memory-Efficient Go Coding Techniques For Better GC Performance ( dev.to )
• fmt.Sprintf vs String Concat ( dolthub.com )
• Go range iterators demystified ( dolthub.com )
• Three Ways To Think About Channels ( dolthub.com )
• Create a DNS Resolver with Golang ( domenicoluciani.com )
• Go Generics: Use Structs for Generic Arguments Lists ( emoses.org )
• Build a URL Shortener with Go, Redis, and HTMX ( getstream.io )
• Go 10 Week Backend Engineering Onboarding ( getstream.io )
• Goroutines in Go: A Practical Guide to Concurrency ( getstream.io )
• Go Structs and Interfaces Made Simple ( getstream.io )
• How a Go Program Compiles down to Machine Code ( getstream.io )
• Writing Secure Go Code ( jarosz.dev )
• Don’t defer Close() on writable files ( joeshaw.org )
• The cost of Go’s panic and recover ( jub0bs.com )
• Don’t pretty print your API’s JSON response body ( jvt.me )
• Generic Concurrency in Go ( kamardin.org )
• Using Go instead of bash for scripts ( kowalczyk.info )
• Making Regex From Scratch in Go ( lewismetcalf.com )
• Putting Go’s Context package into context ( meain.io )
• How I sent 500 million HTTP requests to 2.5 million hosts ( moczadlo.com )
• The Go scheduler (morsmachine.dk)
• if got, want: A Simple Way to Write Better Go Tests ( mtlynch.io )
• Go Slices and Subslices: Understanding Shared Memory and Avoiding append() Pitfalls ( noblet.tech )
• Profiling in Go: A Practical Guide ( nyadgar.com )
• Dumb ways to die: Random Values in Pointers ( philpearl.github.io )
• Abusing Go’s infrastructure ( put.as )
• Go slice gotchas ( rednafi.com )
• Visual Guide to Slices in Go ( sazak.io )
• Common Anti-Patterns in Go Web Applications ( threedots.tech )
• A Guide to the Go Garbage Collector ( tip.golang.org )
• Joining errors in Go ( tpaschalis.me )
• Deep vs Shallow Go interfaces ( tpaschalis.me )
• How to check if a mutex is locked in Go (trailofbits.com)
• victoriametrics golang blogs ( victoriametrics.com )
• Golang Defer: From Basic To Traps ( victoriametrics.com )
• Container CPU Requests & Limits Explained with GOMAXPROCS Tuning ( victoriametrics.com )
• Vendoring, or go mod vendor: What Is It? ( victoriametrics.com )
• How Go Arrays Work and Get Tricky with For-Range ( victoriametrics.com )
• Graceful shutdown ( victoriametrics.com )
• gRPC in Go: Streaming RPCs, Interceptors, and Metadata ( victoriametrics.com )
• How HTTP/2 Works and How to Enable It in Go ( victoriametrics.com )
• Go I/O Closer, Seeker, WriterTo, and ReaderFrom ( victoriametrics.com )
• Go I/O Readers, Writers, and Data in Motion ( victoriametrics.com )
• Go Maps Explained: How Key-Value Pairs Are Actually Stored ( victoriametrics.com )
• From net/rpc to gRPC in Go Applications ( victoriametrics.com )
• Practical Protobuf - From Basic to Best Practices ( victoriametrics.com )
• How Protobuf Works—The Art of Data Encoding ( victoriametrics.com )
• Go Runtime Finalizer and Keep Alive ( victoriametrics.com )
• Slices in Go: Grow Big or Go Home ( victoriametrics.com )
• Go sync.Map: The Right Tool for the Right Job ( victoriametrics.com )
• Go sync.Once is Simple… Does It Really? ( victoriametrics.com )
• Go sync.Pool and the Mechanics Behind It ( victoriametrics.com )
• Go sync.WaitGroup and The Alignment Problem ( victoriametrics.com )
• Inside Go’s Unique Package: String Interning Simplified ( victoriametrics.com )
• Weak Pointers in Go: Why They Matter Now ( victoriametrics.com )
• Nil channels in Go ( vishnubharathi.codes )
• Sets in Go ( willem.dev )

PriorityQueue

• https://dev.to/jpoly1219/linked-lists-in-go-3g63
• https://simiokunowo.hashnode.dev/demystifying-priority-queues-and-applications-in-go
• https://sergetoro.com/posts/golang-priority-queue/
• https://reintech.io/blog/implementing-priority-queues-in-go
• https://medium.easyread.co/today-i-learned-using-priority-queue-in-golang-6f71868902b7

Videos

• Advanced Go Concurrency Patterns ( Google I/O ‘13 )
• Advanced Testing with Go ( GopherCon ‘17 )
• Asynchronous Networking Patterns ( GopherCon ‘18 )
• Effective ingress traffic management with Traefik ( GopherCon ‘17 )
• Go Anti-Patterns ( GopherCon ‘17 )
• Go Class ( k0dvb-tv )
• Go Programmer’s Guide to Syscalls ( GopherCon ‘17 )
• Go scheduler: Implementing language with lightweight concurrency ( Hydra conf ‘19 )
• High-Assurance Go Cryptography ( GopherCon ‘23 )
• Inside the Map Implementation ( GopherCon ‘16 )
• Rethinking Classical Concurrency Patterns ( GopherCon ‘18 )
• Scheduler Saga ( GopherCon ‘18 )
• Two Go Programs, Three Different Profiling Techniques ( GopherCon ‘19 )
• Understanding Allocations: the Stack and the Heap ( GopherCon SG ‘19)
• Understanding Channels ( GopherCon ‘17 )
• Understanding nil ( GopherCon ‘16 )

Tools

• https://github.com/sourcegraph/conc
• https://github.com/outrigdev/outrig
• https://github.com/doganarif/portfinder
• https://github.com/PacktPublishing/Network-Automation-with-Go
• https://github.com/gonum/plot
• https://github.com/shizunge/endlessh-go

Other

• https://victoriametrics.com/blog/alerting-recording-rules-alertmanager/
• https://victoriametrics.com/blog/prometheus-monitoring-instant-range-query/
• https://victoriametrics.com/blog/prometheus-monitoring-metrics-counters-gauges-histogram-summaries/
• https://promlabs.com/blog/2022/12/11/avoid-these-6-mistakes-when-getting-started-with-prometheus/

Quick references

• https://awesome-go.com/
• https://gobyexample.com/
• https://goperf.dev/
• https://ueokande.github.io/go-slice-tricks/

Sort

• https://docs.hatchet.run/blog/go-agents
• https://medium.com/@aditimishra_541/go-performance-with-ubers-automaxprocs-8f31226a92cd
• https://medium.com/@talktopj/sorting-in-go-from-slices-to-structs-d31862339044
• https://dev.to/shrsv/go-contexts-a-practical-guide-to-managing-concurrency-and-cancellation-4gm2
• https://dev.to/leapcell/sync-or-channel-the-right-choice-for-go-synchronization-2m7i
• https://dev.to/leapcell/everything-about-generics-in-go-4hak
• https://dev.to/devbyj/a-basic-golang-project-makefile-1nhe
• https://dev.to/tavernetech/go-interfaces-explained-why-how-and-wow-4al1
• https://dev.to/abstractmusa/mastering-pointers-in-go-a-complete-beginner-to-advanced-guide-213b
• https://dev.to/iamismile/understanding-scope-in-go-1m61
• https://jub0bs.com/posts/2025-05-29-pure-vs-impure-iterators-in-go/
• https://dev.to/leapcell/from-zero-to-neural-networks-in-go-concepts-structure-and-practical-implementation-1od6
• https://redcanary.com/blog/testing-and-validation/fuzzing/
• https://www.dolthub.com/blog/2023-12-01-why-are-go-heaps-confusing/
• https://www.dolthub.com/blog/2024-07-24-static-analysis/
• https://www.dolthub.com/blog/2023-04-14-keep-calm-and-panic/
• https://sd2995.medium.com/fuzzing-in-golang-647946e0df6a
• https://r2p.dev/b/2024-03-18-1brc-go/
• https://blog.openziti.io/zero-trust-sshclient