A growing collection of websites, tools, and references I keep coming back to. Bookmarking individual links gets messy fast, so this page is my source of truth for the corners of the internet worth remembering. Updated as I find them.

Learning & Tutorials

  • Go by Example : Hands-on introduction to Go with annotated, runnable example programs. The fastest way to get productive in Go if you already know another language.
  • The Rust Book : The official Rust learning resource. Comprehensive, well-paced, and the standard starting point for the language.
  • Rustlings : Small exercises that get you used to reading and writing Rust. The companion drill book to The Rust Book.
  • Crafting Interpreters : Bob Nystrom’s book on building two interpreters from scratch. Even if you’ll never write a compiler, it makes you a sharper programmer.
  • Operating Systems: Three Easy Pieces (OSTEP) : A free OS textbook that’s actually fun to read. The standard recommendation for learning OS fundamentals.
  • Build Your Own X : A massive index of “build your own database / git / shell / regex engine” tutorials. Pick a project, learn by reconstructing.
  • The Missing Semester of Your CS Education : MIT’s short course on the tools every developer uses but no one teaches: shell, tmux, vim, debuggers, version control.
  • Teach Yourself CS : A curated, opinionated reading list to build CS fundamentals on your own. One book and one course per topic.
  • Full Stack Open : University of Helsinki’s free, no-nonsense React + Node course. One of the best free resources for modern web development.
  • Learn X in Y Minutes : A whirlwind tour of any language’s syntax on a single page. Perfect for “I know how to program, just show me the syntax.”
  • Beej’s Guide to Network Programming : The classic, friendly intro to sockets in C. Still the best starting point for low-level networking.
  • MIT 6.5840 (Distributed Systems) : Robert Morris’s distributed systems course. Free lectures, paper list, and labs that build a fault-tolerant Raft-backed KV store.

Practice & Challenges

  • Coding Challenges : John Crickett’s weekly challenges to rebuild real-world tools from scratch (wc, cut, JSON parser, Redis clone, and more). Far more satisfying than grinding interview problems.
  • Advent of Code : Eric Wastl’s December puzzle calendar. Two new problems a day, increasingly devious, and a perfect excuse to try a new language each year.
  • Project Euler : Math-heavy programming problems that force you to think about complexity and clever number theory, not just data structures.
  • Exercism : Mentored coding exercises across 70+ languages. The mentor feedback on submitted solutions is what really sets it apart.
  • System Design Primer : Open-source guide and question bank for system design. Comprehensive, frequently updated, and the canonical free resource.
  • Protohackers : Network programming challenges where you implement TCP/UDP servers against a real grader. Brilliant if you want to actually feel sockets.
  • Codewars : Bite-sized kata across many languages. Good for short bursts of practice and comparing your solution to others.
  • Cryptopals : Eight sets of cryptography challenges that take you from “what is XOR” to breaking real ciphers. Genuinely brilliant.
  • OverTheWire : Linux and security wargames played over SSH. Bandit is the best intro to working in a Unix shell I know of.
  • pwn.college : A free, structured infosec curriculum from Arizona State, run as a hands-on dojo of binary exploitation and systems security challenges.
  • Frontend Mentor : Real design files and challenges for practicing frontend. Great if you learn by recreating production-looking UIs.
  • Monkeytype : Minimal, customizable typing test that has become the dev-community standard for benchmarking raw keyboard speed. Surprisingly addictive once you start chasing a higher WPM.

Git & Version Control

  • Pro Git Book : The free, official Git book by Scott Chacon and Ben Straub. The single best resource for actually understanding Git’s model rather than memorizing commands.
  • Oh Sh*t, Git!?! : Plain-English fixes for the most common Git messes. Bookmark it now, you’ll need it.
  • Learn Git Branching : An interactive, visual tutorial that builds real intuition for branches, rebases, and merges by letting you watch the graph evolve as you type commands.
  • Atlassian Git Tutorials : Clear, diagram-heavy explanations of every Git workflow. Often the first hit when you Google how a command works, and usually the best.
  • How to Write a Git Commit Message : Chris Beams’ seven rules for writing useful commit messages. The reason most well-maintained repos look the way they do.
  • Conventional Commits : A simple specification for commit messages that machines and humans both find readable. Pairs naturally with semver and automated release tooling.

Cloud & DevOps

  • AWS Well-Architected Framework : AWS’s six-pillar framework (operational excellence, security, reliability, performance, cost, sustainability) for evaluating cloud architectures. The vocabulary every cloud engineer ends up using.
  • Google Cloud Architecture Center : Reference architectures, best practices, and case studies across GCP. Useful even if you’re not on GCP.
  • Azure Architecture Center : Microsoft’s equivalent, with a notably good catalog of cloud design patterns.
  • Google SRE Book : The book that gave the industry the language for SLOs, error budgets, and toil. Free online.
  • The SRE Workbook : The follow-up, focused on putting the ideas into practice. Read after the SRE Book.
  • DORA / State of DevOps : Home of the four DORA metrics and the annual State of DevOps report. The closest thing the industry has to measurable evidence of what works.
  • CNCF Landscape : A map of every cloud-native project in existence. Overwhelming on purpose, useful when you need to figure out what tool fits a niche.
  • Roadmap.sh : Community-curated learning paths for DevOps, backend, SRE, and dozens more. A solid “where do I even start” reference.

Architecture & System Design

  • Martin Fowler : The reference site for software architecture, refactoring, microservices, and enterprise patterns. Decades of clear, durable writing.
  • Microservices.io : Chris Richardson’s catalog of microservice patterns, with diagrams, trade-offs, and real-world context.
  • AWS Builders’ Library : Long-form articles where senior AWS engineers explain how they actually build and run services. One of the most underrated technical resources online.
  • C4 Model : A lightweight notation for diagramming software architecture at four levels (context, container, component, code). Simple enough to actually use.
  • Architectural Decision Records : A template and toolkit for capturing the why behind architectural choices in your repo, before the reasoning gets lost.
  • Awesome Scalability : A massive, well-maintained reading list of scalability, availability, and performance case studies.
  • ThoughtWorks Technology Radar : A twice-yearly snapshot of which technologies, techniques, and platforms are worth adopting, trialling, or avoiding.
  • InfoQ Architecture & Design : News, articles, and conference talks on software architecture. Good for staying current on what the industry’s actually doing.

Engineering Practices & Guides

  • Google Engineering Practices : Google’s public code review developer guide, including how to review code and how to write the CL you submit. The single best document on giving and receiving code review feedback.
  • Google Style Guides : Google’s open-source style guides for C++, Python, Java, Go, JavaScript, Shell, and more. Even if you disagree, knowing where they land is useful.
  • Google Developer Documentation Style Guide : Detailed conventions for writing developer-facing docs. The closest thing to a published “house style” for technical writing.
  • Microsoft Writing Style Guide : Microsoft’s writing guide, broader in scope than Google’s and arguably the gold standard for technical writing in English.
  • The Twelve-Factor App : The cleanest statement of how cloud-native apps should be built. Old, short, still right.
  • Semantic Versioning : The MAJOR.MINOR.PATCH spec. If you publish anything anyone else consumes, follow this.
  • Keep a Changelog : A simple, durable format for writing changelogs. Saves you from “various bug fixes” entries forever.
  • Choose a License : A GitHub-curated, plain-English guide to picking an open-source license. Stops you from doing the wrong thing in five minutes.
  • Diátaxis : A four-quadrant framework (tutorials, how-tos, reference, explanation) for organizing documentation. Adopted by Django, NumPy, and many others.
  • Contributor Covenant : The most widely adopted code of conduct for open-source communities. The default if you’re not sure where to start.

References & Wikis

  • The Algorithms : Open-source implementations of classic algorithms and data structures across many languages. Great for cross-language comparisons and as a quick refresher.
  • OSDev Wiki : The canonical reference for anyone writing an operating system from scratch. Bootloaders, paging, scheduling, drivers, it’s all here.
  • MDN Web Docs : The authoritative reference for HTML, CSS, JavaScript, and web APIs. If a browser does it, MDN documents it well.
  • cppreference : The reference for C and C++. Far better organized and more accurate than the official standard library docs.
  • DevDocs : Unified, offline-capable docs browser for dozens of languages and frameworks. One search bar across everything.
  • man7.org Linux man pages : Michael Kerrisk’s well-maintained mirror of Linux man pages. Cleaner to read on the web than man in a terminal.
  • Compiler Explorer (Godbolt) : Paste code in any of 30+ languages, see the assembly the compiler actually emits. Indispensable when you want to see what your high-level code becomes at the instruction level.
  • Refactoring Guru : Design patterns and refactoring techniques explained with diagrams and examples in multiple languages.
  • Use The Index, Luke : Markus Winand’s free, vendor-neutral guide to SQL indexing and query performance. Will change how you write SQL.
  • Database of Databases (dbdb.io) : CMU’s encyclopedic catalog of every database system ever, with comparable specs and history. A delight to browse.
  • Regex101 : Interactive regex tester with explanations of every token. The first tab I open whenever I’m writing a non-trivial pattern.
  • Explainshell : Paste a shell command, get every flag and pipe explained. Indispensable for parsing someone’s incomprehensible one-liner.

Blogs & Creators

  • Semicolony : A developer’s space with thoughtful projects, deep dives, and writing about the craft. Worth a follow for the breadth.
  • Martin Kleppmann : Author of Designing Data-Intensive Applications, researcher in distributed systems and local-first software. His writing is uniformly excellent.
  • Dan Luu : Data-driven essays on software, hardware, hiring, and why so many things in this industry are worse than they should be.
  • Julia Evans (jvns.ca) : Friendly, illustrated deep dives into how computers actually work: networking, debuggers, the Linux kernel. The zines are gold.
  • Aphyr / Jepsen : Kyle Kingsbury’s blog and the Jepsen distributed-systems testing reports. The bar for “is this database actually correct?”
  • Brendan Gregg : Performance engineering, profiling, flame graphs, eBPF. If something is slow in production, his site has the technique to find out why.
  • Eli Bendersky : Patient, deeply-researched posts on compilers, Go, low-level systems, and CS fundamentals.
  • Russ Cox (research.swtch.com) : Go core team, language design, regex, supply chain. Among the clearest technical writers working today.
  • Marc Brooker : AWS principal engineer writing about distributed systems in practice. Excellent on the gap between theory and operating a service.
  • Arpit Bhayani : System design and database internals explained with depth and clarity. Approachable deep dives into how production systems actually work, well-loved in the backend community.
  • Ben Kuhn : Engineering management, productivity, and decision-making essays from Anthropic’s CTO. Short and consistently sharp.
  • Kalzumeus / Patrick McKenzie : Long-form essays on software business, careers, and how the world works behind the scenes. See also Bits about Money .
  • Joel on Software : Joel Spolsky’s archive. Two decades of essays on shipping software that mostly still hold up.
  • Paul Graham : Founder-focused essays from the Y Combinator co-founder. Aimed at startups, often applicable far beyond.
  • High Scalability : Long-running aggregator and originator of “X stack at company Y” architecture write-ups. The genre’s home page.
  • Cloudflare Blog : Easily the best big-company engineering blog. Deep, frequent posts on networking, performance, and edge infrastructure.

Have a link worth adding? Email me , always looking for more.