Original post

Important Reading

There is a ton of links to extra reading and videos through out the material. Occasionally we run into material that we feel is important and don’t have an exact place to put it. This is a section place for that material.


Go In Action – Kennedy, Ketelsen, St. Martin
Get Programming with Go – Nathan Youngman, Roger Peppé
The Go Programming Language – Alan Donovan, Brian Kernighan
Go Programming Blueprints – Mat Ryer
Mastering Go – Mihalis Tsoukalos
Head First Go – Jay McGavren


Ardan Labs Blog – William Kennedy
The acme of foolishness – Dave Cheney
The Go Blog – Language Team
Ukiah Smith – Ukiah Smith
Mechanical Sympathy – Martin Thompson
Go Documentation References – Language Team
Vincent Blanchon – Vincent Blanchon


An Interview with Brian Kernighan
Interview with Dennis Ritchie, Bjarne Stroustrup, and James Gosling
“C” Programming Language: Brian Kernighan
Language Design with Brian Kernighan


The Go Programming Language – Official Announcement – Rob Pike
The Evolution of Go – Robert Griesmer
Less Is Exponentially More (2012) – Rob Pike
Language Design in the Service of Software Engineering – Rob Pike
A Very Brief History of Computing, 1948-2015 – Martyn Thomas
The Rise and Fall of Minicomputers – Gordon Bell
After Moore’s Law – Economist – Tim Cross
A Crash Course in Modern Hardware – Cliff Click
The Future of Programming – Uncle Bob
The Best Programming Advice I Ever Got – Rob Pike
A Retrospective on SEDA – Matt Welsh
Software Development for Infrastructure – Bjarne Stroustrup
Let’s stop copying C – Eevee
15 Years of Concurrency – Joe Duffy
Normalization of Deviance in Software – danluu.com
The Future of Programming – Bret Victor
Systems Past: the only 8 software innovations we actually use – davidad
Lessons learned from reading postmortems – danluu.com
Early days of Unix and design of sh – Stephen Bourne
What did Alan Kay mean by, “Lisp is the greatest single programming language ever designed”? – Alan Kay
What Have We Learned from the PDP-11? – C. Gordon Bell
4 lessons for modern software developers from 1970s mainframe programming – Alan Zeichick
Notes on Programming in C – Rob Pike
The Why of Go – Carmen Andoh
The Transistor, Part 3: Endless Reinvention – technicshistory
Reflections on Trusting Trust – Ken Thompson
Null References: The Billion Dollar Mistake – Tony Hoare
Go’s History in Code – Sean Hinchee

Contribute to

Contributing to the Go project – Matt Layher
Contribution Guidelines – Go Documentation
CONTRIBUTING: The Talk! – Michael Matloob

Standard Library

io package – Ben Johnson
bytes + strings packages – Ben Johnson
encoding package – Ben Johnson
strconv package – Ben Johnson

Testing and Structure

Structuring Tests in Go – Ben Johnson
Structuring Applications in Go – Ben Johnson
Advanced Testing with Go – Video – Mitchell Hashimoto
Advanced Testing with Go – Deck – Mitchell Hashimoto
The tragedy of 100% code coverage – Daniel Lebrero’s
Logs and Metrics – Cindy Sridharan
The deep synergy between testability and good design – Michael Feathers


Go & Versioning – Russ Cox
Using Go Modules – Go Team
Modules Part 01: Why And What – William Kennedy
Modules Part 02: Projects, Dependencies and Gopls – William Kennedy
Modules Part 03: Minimal Version Selection – William Kennedy
Modules Part 04: Mirrors, Checksums and Athens – William Kennedy
Modules Part 04: Mirrors, Checksums and Athens – Rohan Challa
Modules Part 05: Gopls Improvements – William Kennedy
Modules Part 06: Vendoring – William Kennedy
Go Wiki on Modules – Community
Go Modules – systemdump
A Gentle Introduction To Go Modules – Ukiah Smith

Vendoring / Versioning

How one developer just broke Node, Babel and thousands of projects in 11 lines of JavaScript
The End of Software Versions – Pieter Hintjens
Transparent Logs for Skeptical Clients – Russ Cox

Profiling, Debugging and Optimization

Precise timing of machine code with Linux perf. – Denis Bakhvalov
The past and future of Microprocessor performance – Dave Cheney
Want to Debug Latency? – JBD
Language Mechanics On Escape Analysis – William Kennedy
Profiling Go Programs – Go Team
Profiling & Optimizing in Go – Brad Fitzpatrick
Go Dynamic Tools – Dmitry Vyukov
How NOT to Measure Latency – Gil Tene
Go Performance Tales – Jason Moiron
Debugging performance issues in Go programs – Dmitry Vyukov
Reduce allocation in Go code – Python Bytes
Write High Performance Go – Dave Cheney
Static analysis features of godoc – Go Team
Go’s execution tracer – Rhys Hiltner
Using Instruments to profile Go programs – Burcu Dogan
Designing for Performance – Martin Thompson
Fighting latency: the CPU profiler is not your ally – Filippo Valsorda
go tool trace – Will Sewell
Analyzing production using Flamegraphs – Prashant Varanasi
Go’s hidden #pragmas – Dave Cheney
Post-mortem debugging of Go Programs – Lorenzo Fontana
A Crash Course in Modern Hardware – Cliff Click
How I investigated memory leaks in Go using pprof on a large codebase – Jonathan Levison

API Design

You wanted a banana but you got a gorilla holding the banana – John D. Cook
Focus On Being Precise – William Kennedy
Design, Composition and Performance – Rich Hickey
Things That Matter – Scott Meyers

Error Handling

Go 1.13: xerrors – David Crawshaw
Error handling and Go
Error Handling In Go, Part I – William Kennedy
Error Handling In Go, Part II – William Kennedy
Design Philosophy On Logging – William Kennedy
Bugs are a failure of prediction – Matt Sherman
Inspecting errors – Dave Cheney
Don’t just check errors, handle them gracefully – Dave Cheney
Stack traces and the errors package – Dave Cheney
Errors are handled in return values – Russ Cox
Error handling in Upspin – Rob Pike
Why Go’s Error Handling is Awesome – Raul Jordan

Interfaces and Composition

Repeat yourself, do more than one thing, and rewrite everything – tef
Interface Values Are Valueless – William Kennedy
Interface Semantics – William Kennedy
Design Guidelines
Interface Pollution – Burcu Dogan
Abstraction Considered Harmful – Brave New Geek
Methods, Interfaces and Embedding – William Kennedy
Composition In Go – William Kennedy
Reducing Type Hierarchies – William Kennedy
Avoid Interface Pollution – William Kennedy
Hyrum’s Law – Hyrum


The Behavior Of Channels – William Kennedy
Scheduling In Go – Part I – William Kennedy
Scheduling In Go – Part II – William Kennedy
Go advanced concurrency patterns: part 3 (channels) – Roberto Clapis

Buffer Bloat – 2011

Bufferbloat: Dark Buffers in the Internet – Jim Gettys
Buffer Bloat Videos


Measuring context switching and memory overheads for Linux threads – Eli Bendersky’s
Linux Performance – Brendan Gregg
The Definitive Guide to Linux System Calls
Linux Performance Analysis in 60,000 Milliseconds – Netflix
Tenets of the UNIX Philosophy – Mike Gancarz
Monitoring and Tuning the Linux Networking Stack: Receiving Data – packagecloud
The Linux Scheduler: a Decade of Wasted Cores
Path: add BBR congestion control

Container, Orchestration and Kubernetes

How To Deploy a Go Web Application with Docker – Kulshekhar Kabra
An introduction to Clear Containers – LWN.net
Getting Started with Docker – Docker
Kubernetes Bootcamp – Google
Kubernetes Liveness and Readiness Probes – Colin Breck
What happens when … Kubernetes edition! – Jamie Hannaford

Distributed Systems

Notes on Distributed Systems for Young Bloods – Jeff Hodges
The Queen Does Not Rule – Deborah M Gordon
Load Balancing is Impossible – Tyler McMullen
Dapper: Distributed Tracing – Google
Authentication in Distributed Systems: Theory and Practice – Microsoft

HTTP and Timeouts

Complete Guide To Go Net HTTP Timeouts – Filippo Valsorda

Queuing Theory

Basic Queuing Theory – Dr. János Sztrik
Queueing Theory – Eben Freeman
Designing Cluster Schedulers for Internet-Scale Services – Diptanu Gon Choudhury and Timothy Perrett
Observations on Buffering – Owen Grimoire

Specter And Other CPU Attacks

Different CPU attack
An analysis of side-channels and speculative execution – White Paper
Hiding Malware in Speculative Execution – White Paper
Speculation & leakage: Timing side channels & multi-tenant computing (SEC355) – Eric Brandwine

Go Assembly

Go Assembly by Example – David Wong
Quick intro to Go assembly
The Go low-level calling convention on x86-64 – Raphael ‘kena’ Poss

Site Reliability Engineering

Site Reliability Engineering – Google
SLI, SLO, SLA – Google
SLIs, SLOs, SLAs, oh my! – Liz Fong-Jones and Seth Vargo

Monitoring and Observability

Health and availability in computer systems – José Carlos Chávez


Learn How To Optimize Code In Go – Dave Cheney


Why We Can’t Divide By Zero – Eddie Woo
Shrink Your Go Binaries With This One Weird Trick – Filippo Valsorda
USENIX Association Videos
Latency Tip Of The Day — Gil Tene
Proposal: Monotonic Elapsed Time Measurements in Go – Russ Cox
Exploring shared objects in Go – Marcelo Bytes
Evaluation of read-only slices – Russ Cox
The Magical Number Seven, Plus or Minus Two – Wikipedia
Our Human Condition “From Space” – Alan Kay
No Silver Bullet: Essence and Accidents of Software Engineering – Frederick P. Brooks, Jr.
Psychology of Code Readability – Egon Elbre
Divide By Zero – Hillel Wayne
Secrecy, Authentication, and Public Key Systems – Ralph Merkle
Tales From The Lunar Module Guidance Computer – Don Eyles
Is Self-Orientation Killing Your Trustworthiness – Charles H. Green
Speed Is Found In The Minds of People – Andrei Alexandrescu
The Soul of Erlang and Elixir – Saša Jurić

Must Read

PRinty# C with ABC – Dr. Tom Murphy VII, Ph.D
I coached 101 CEOs, founders, VCs and other executives in 2019: These are the biggest takeaways – Leo Widrich

Go 2

Type Parameters – Draft Design : June 2020 – Go Team
Sydney Golang Meetup – Rob Pike – Go 2 Draft Specifications – Rob Pike

Mechanical Sympathy

Much of this content can be found under arrays and data races. We feel this content is so important it has been moved out to this general materials page.

CPU Caches / Memory

CPU Caches and Why You Care – Video – Scott Meyers
CPU Caches and Why You Care – Deck – Scott Meyers
NUMA Deep Dive Series – Frank Denneman

Mythbusting Modern Hardware to Gain ‘Mechanical Sympathy` – Martin Thompson
What Every Programmer Should Know About Memory – Ulrich Drepper
How CPU Caches Work and Why – Joel Hruska
Modern Microprocessors A 90 Minute Guide – Jason Robert Carey Patterson
Memory part 2: CPU caches – Ulrich Drepper
The Free Lunch Is Over – Herb Sutter
Data Center Computers: Modern Challenges in CPU Design – Dick Sites
Wirth’s Law – Wikipedia
Eliminate False Sharing – Herb Sutter
The Myth Of Ram – Emil Ernerfeldt
Understanding Transaction Hardware Memory – Gil Gene
Want fast C++? Know your hardware! – Timur Doumler
Performance Through Cache-Friendliness (4:25-5:48) – Damian Gryski
Going Nowhere Faster – Chandler Carruth
Meltdown and Spectre – Adrian Colyer

Data-Oriented Design

Building a Data-Oriented Future – Mike Acton
Data-Oriented Design and C++ – Mike Acton
Efficiency with Algorithms, Performance with Data Structures – Chandler Carruth
Taming the performance Beast – Klaus Iglberger

Pitfalls of OOP – Tony Albrecht
Why you should avoid Linked Lists – Bjarne Stroustrup
Data-Oriented Design (Or Why You Might Be Shooting Yourself in The Foot With OOP) – Noel
Was object-oriented programming a failure? – Quora

Operating Systems and Virtualization

The Linux Scheduler: a Decade of Wasted Cores
The Cost of Virtualization – Ulrich Drepper
NUMA Deep Dive Series – Frank Denneman


This content can be found under pointers. We feel this content is so important it has been moved out to this general materials page.


Building a better Go linker – Austin Clements


Contiguous Stack Proposal
Fix corruption crash/race between select and stack growth – Russ Cox
Defer Proposal – Go Team


Go scheduler: Implementing language with lightweight concurrency – Dmitry Vyukov
How does the golang scheduler work? – Ian Lance Taylor
Explanation of the Scheduler
proposal: runtime: non-cooperative goroutine preemption – Austin Clements
Go scheduler: Implementing language with lightweight concurrency – Dmitry Vyukov
Work-Stealing in Go Scheduler – Vincent Blanchon

Escape Analysis and Inlining

Go Escape Analysis Flaws – Dmitry Vyukov
Escape-Analysis Flaws Updated – William Kennedy
Compiler Optimizations

Garbage Collection

The Garbage Collection Handbook
Tracing Garbage Collection – Wikipedia
Go Blog – 1.5 GC
Go GC: Solving the Latency Problem – Rick Hudson
Concurrent garbage collection
Go 1.5 concurrent garbage collector pacing
Eliminating Stack Re-Scanning – Austin Clements
Simplify mark termination and eliminate mark 2 – Austin Clements
Why golang garbage-collector not implement Generational and Compact gc? – Ian Lance Taylor
Getting to Go: The Journey of Go’s Garbage Collector – Rick Hudson

Single Static Assignment Optimizations

GopherCon 2015: Static Code Analysis Using SSA – Ben Johnson
Understanding Compiler Optimization – Chandler Carruth


Runtime Hacking
Timer implementation – Ian Lance Taylor
The Go low-level calling convention on x86-64 – Raphael ‘kena’ Poss
Memory Management – Unknown


Learn how to build a processor
Reading Silicon: How to Reverse Engineer Integrated Circuits – Ken Shirriff

Release Notes

Open issues for the upcoming release

Go 1.14 Release Notes – 2020/02/26
Go 1.13 Release Notes – 2019/09/03
Go 1.12 Release Notes – 2019/02/25
Go 1.11 Release Notes – 2018/08/24
Go 1.10 Release Notes – 2018/02/16
Go 1.09 Release Notes – 2017/08/24
Go 1.08 Release Notes – 2017/02/16
Go 1.07 Release Notes – 2016/08/15
Go 1.06 Release Notes – 2016/02/17
Go 1.05 Release Notes – 2015/08/19
Go 1.04 Release Notes – 2014/12/10
Go 1.03 Release Notes – 2014/06/18
Go 1.02 Release Notes – 2013/12/01
Go 1.01 Release Notes – 2013/05/13
Go 1.00 Release Notes – 2012/03/28

Research Papers

Interesting Papers – Damian Gryski
“Balls into Bins” — A Simple and Tight Analysis
Thoughts and links about programming – Russ Cox
Rules of Machine Learning – Martin Zinkevich
Algorithm Engineering: Concepts and Practice – Markus Chimani and Karsten Klein