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

  • Semicolony : My favorite and go to developer’s space with study paths, simulators, visualizations, and deep dives across the whole CS stack. One of the most thoughtfully built learning sites out there. Three corners I keep coming back to:
    • Postmortems : Annotated write ups of real infrastructure outages, config failures, data disasters, networking meltdowns, with the operational lessons pulled out cleanly. Better than any textbook on what actually breaks in production. Love it!
    • ELI5 : Complex technical concepts stripped down to their simplest form. The kind of clarity you wish more writing had.
    • Decide : A tool for navigating technical decisions trade-offs surfaced and options compared so you’re not choosing blind.
  • 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.

In my opinion, now AI handles most of the format and conventions pretty well, yet these are still worth a read :)

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

  • 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 : Former Go language lead, now at Google Research. His personal site is an index of projects, papers, and talks spanning Plan 9, regex theory, and systems research going back to the early 2000s — the kind of depth you don’t find anymore. His blog covers Go internals, language design, supply chain, and more, and is among the clearest technical writing 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.