References
A short, curated list: enough to learn from, not a catalogue of everything. Items marked
free can be read or used without paying. Books that cost money are listed by title and author only, so look for them at your library first. For real projects to read and contribute to, see
Study Projects; for the programs of this roadmap, see
Demo Examples.
Go Documentation and Playgrounds
| Resource | Use it for |
|---|
| A Tour of Go free | The official interactive introduction; enough Go to read every demo here. |
| Go Playground free | Run a Go program in the browser and share it by link. Good for the small examples; use a local go run for the larger demos. |
| The Go Specification free | The exact rules for slices, maps, generics, shifts and integer overflow. Short enough to read once through. |
| Effective Go free | Idioms for naming, error handling, interfaces and concurrency. |
| pkg.go.dev free | Documentation and source of every standard-library and public package: container/heap, slices, sort, math/rand/v2, sync, sync/atomic, testing. |
| The Go Memory Model free | What one goroutine is guaranteed to see of another's writes; read it before writing lock-free code. |
| The Go Blog free | Official articles on generics, profiling, slices, maps and concurrency patterns. |
| Profiling Go Programs and Diagnostics free | Measure before optimizing: CPU and memory profiles, traces, and the race detector. |
| Go fuzzing tutorial free | Turn the "compare with an oracle on random input" idea into a fuzz test that the toolchain drives. |
Visualizers and Cheat Sheets
| Resource | Use it for |
|---|
| VisuAlgo free | Animated data structures and algorithms with step-by-step execution and a self-test mode. Watch a structure before you code it. |
| Data Structure Visualizations (USFCA) free | Interactive AVL and B-trees, heaps, hash tables, tries and graph algorithms. Type your own inputs. |
| Big-O Cheat Sheet free | A table of common complexities to check your own analysis against; the Complexity Analysis lesson explains where the numbers come from. |
Free Books and Lecture Notes
| Resource | Use it for |
|---|
| Algorithms by Jeff Erickson free | A complete university text with clear proofs; strong on recursion, dynamic programming and graphs. |
| Open Data Structures by Pat Morin free | Arrays, linked lists, hash tables, skip lists, trees and heaps with implementations and analysis. |
| Competitive Programmer's Handbook by Antti Laaksonen free | A compact tour of sorting, DP, graphs, bit tricks and range queries (Fenwick and segment trees) aimed at contests. |
| Algorithms, 4th edition: book site (Sedgewick and Wayne) free | Free code, exercises, lecture slides and data files that go with the textbook. |
| MIT 6.006 Introduction to Algorithms free | Lecture videos, notes and problem sets from a standard first course. |
| cp-algorithms free | An encyclopedia of algorithms with proofs and complexity: suffix arrays, Z-function, Aho-Corasick, segment trees and more. |
Books Worth Buying or Borrowing
- Introduction to Algorithms (CLRS) by Cormen, Leiserson, Rivest and Stein: the standard reference; rigorous and complete.
- The Algorithm Design Manual by Steven Skiena: practical, with a catalogue of problems and how to recognize them.
- Algorithm Design by Kleinberg and Tardos: excellent on greedy algorithms, dynamic programming and network flow.
- Algorithms by Sedgewick and Wayne: clear code and pictures for sorting, searching, graphs and strings.
- The Go Programming Language by Donovan and Kernighan (gopl.io): the best book for Go itself, including the concurrency chapters behind the last lesson.
- Designing Data-Intensive Applications by Martin Kleppmann: how caches, indexes, logs, partitioning and replication work in real systems; the natural sequel to Production Structures.
- Programming Pearls by Jon Bentley: short essays on choosing the right structure and checking a solution.
Practice Sites
| Site | Use it for |
|---|
| Exercism: Go track free | Small exercises in Go with feedback from volunteer mentors. Best for learning idiomatic Go. |
| CSES Problem Set free | About 300 classic problems in a sensible order: sorting, DP, graphs, trees, strings. Accepts Go. |
| USACO Guide free | A structured path from beginner to advanced, with problems for each topic. |
| LeetCode | Interview-style problems; a free tier is available. Useful once the lessons are done. |
| Codeforces and AtCoder free | Timed contests with editorials; the strongest practice for speed and problem recognition. |
| Advent of Code free | Puzzles every December that reward graphs, parsing, DP and careful data structures. |
| Project Euler free | Math-flavored problems where a brute-force solution is too slow: practice for complexity analysis. |
The Papers Behind the Lessons
Original papers are shorter and easier than their reputation, and they give the reasoning that textbooks skip. The three with links are free to read online; for the others, search the title.
| Lesson | Paper |
|---|
| Advanced Trees | Adelson-Velsky and Landis, "An algorithm for the organization of information" (1962), the AVL tree. Aragon and Seidel, "Randomized Search Trees" (1989/1996), the treap. |
| String Algorithms | Knuth, Morris and Pratt, "Fast pattern matching in strings" (1977). Aho and Corasick, "Efficient string matching: an aid to bibliographic search" (1975). |
| Bloom Filter | Bloom, "Space/time trade-offs in hash coding with allowable errors" (1970). |
| Count-Min Sketch | Cormode and Muthukrishnan, "An improved data stream summary: the count-min sketch and its applications" (2005). |
| HyperLogLog | Flajolet, Fusy, Gandouet and Meunier, "HyperLogLog: the analysis of a near-optimal cardinality estimation algorithm" (2007). |
| Consistent Hashing | Karger et al., "Consistent hashing and random trees" (1997). Lamping and Veach, "A Fast, Minimal Memory, Consistent Hash Algorithm" (2014), the jump hash. |
| LRU Cache and Admission | Einziger, Friedman and Manes, "TinyLFU: A Highly Efficient Cache Admission Policy" (2015). |
How to Use These References
- One primary text. Pick one book or lecture series from the free list and follow it alongside the roadmap. Reading three books at once means finishing none.
- See, then write. Watch the structure in a visualizer, write it from memory in the Playground, then compare with the demo and finally with a library from Study Projects.
- Practice on a schedule. A few problems each week on CSES or Exercism teach more than a weekend of marathon solving.
- Check claims. Any figure in this roadmap (a hit ratio, an error rate, a speedup) comes from a program you can run. Do the same for what you read elsewhere.
