This is a curated list of programming & software engineering articles that I've personally found to be interesting over the years. I hope it proves useful to others too.
I periodically update this list. Please open an issue if any of the links are dead.
- Blogs
- Career
- Data Structures & Algorithms
- Data Design/Databases
- Deep dives/Performance/Retrospectives
- Developer Experience/Tooling
- Distributed Systems/System Design
- Hardware/Low Level
- History/News
- Humour/Rants/Satire
- Networking/Web
- Mobile Development
- Privacy & Security
- Programming Languages/Theory
- Software Engineering
- Uncategorized
- Cloudflare's blog
- Discord's Blog
- Facebook's blog
- Github's Blog
- Netflix Technology Blog
- Riot Game's Blog
- Shopify's Blog
- CodingHorror
- Joe Duffy's Blog
- Joelonsoftware
- Martin Fowler's blog
- The Pragmatic Engineer's blog (free) and newsletter (paid)
- Stephen Colebourne (creator of Joda Time)'s blog
- Steve Yegge's blog and medium
- stuffwithstuff
- 10 hard-to-swallow truths they won't tell you about software engineer job
- 16x Engineer
- 20 Questions a Software Engineer Should Ask When Joining a New Team
- 8 Hard Truths I learned when I got laid off from my SWE job
- A forty-year career
- An Engineering Team where Everyone is a Leader
- Becoming a go-to person gets you promoted. Here's how to do it as a software engineer.
- Being Glue
- Building trust as a software engineer
- Cruise Ships
- Engineering Ladders
- Falsehoods Junior Developers believe about becoming Senior
- Hiring in Tech
- How to land the manager-to-IC pivot
- How to Lead a Project - as a Software Engineer
- How to mentor software engineers
- Level Up
- Principal / Staff Engineer Resources
- Reddit Interview Problems: The Game of Life
- Staff archetypes
- Software Engineer roadmap via books
- Tech Resume Advice
- The Two Healthbar Theory of Burnout
- The Two Tiers of Singapore's Tech Companies
- Things I've learned transitioning from engineer to engineering manager
- What a truly engaged engineer looks like
- What does a CTO actually do?
- What I learned from Software Engineering at Google
- What is a Staff Engineer?
- What we look for in a resume
- What’s going on with Google and Facebook?
- What's it like as a Senior Engineer at Google?
- Why GitHub Won't Help You With Hiring
- Writing for Engineers
- Your 2020 Guide for Surviving Interviewing as a Software Engineer
- Analyzing New Unique Identifier Formats (UUIDv6, UUIDv7, and UUIDv8)
- A primer on Roaring bitmaps: what they are and how they work
- Beautiful Branchless Binary Search
- Concurrent Data Structure Design Walkthrough
- Hierarchical Clearance-based Pathfinding
- Parsing: The Solved Problem That Isn't
- The Piece Table
- Unicode is harder than you think
- A lesson in address storage
- Choose Postgres queue technology
- Database Design For Audit Logging
- Don't Do This
- Hierarchies on Steroids #1: Convert an Adjacency List to Nested Sets
- How To Corrupt An SQLite Database File
- How we optimized PostgreSQL queries 100x
- In praise of PostgreSQL
- I'm All-In on Server-Side SQLite
- Migrating a production database without any downtime
- Nine ways to shoot yourself in the foot with PostgreSQL
- Relational Databases Aren’t Dinosaurs, They’re Sharks
- Soft Deletion Probably Isn't Worth It
- The Inner Workings of Distributed Databases
- Towards Inserting One Billion Rows in SQLite Under A Minute
- Transactional DDL in PostgreSQL: A Competitive Analysis
- Why You Should Never Use MongoDB
- 4 Billion If Statements
- After 14 years in the industry, I still find programming difficult
- Building a Date-Time Library: Timezones (Disclaimer: written by me)
- Burning money on paid ads for a dev tool – what we've learned
- Discovering the Local Time Zone: Why It's a Hard Problem
- Donald Knuth's thoughts on ChatGPT
- Down the ergonomic keyboard rabbit hole
- Faster Chrome - Let The Compiler do the work
- From Laptop to Lambda: Outsourcing Everyday Jobs to Thousands of Transient Functional Containers
- Goodbye, Twilio
- Here's a problem that sounded impossible...
- How I cut GTA Online loading times by 70%
- How They Bypass YouTube Video Download Throttling
- I built a garbage collector for a language that doesn't need one
- I made JSON.parse() 2x faster
- Lessons learnt while trying to modernize some C code
- Reflections on 10,000 Hours of Programming
- Saying Goodbye to the Best Gig I Ever Had
- SIMD accelerated sorting in Java - how it works and why it was 3x faster
- The 100% Markdown Expedition
- The Billion Row Challenge (1BRC) - Step-by-step from 71s to 1.7s
- The Hardest Program I've Ever Written
- Two years for developing an MMO
- Whose bug is this anyway?!?
- Why Cities: Skylines 2 performs poorly
- Why is processing a sorted array faster than processing an unsorted array
- Automating a software company with GitHub Actions
- CI/CD/CF? — The DevOps toolchain’s “missing-link”
- Developer tools can be magic. Instead, they collect dust
- DevEx: What Actually Drives Productivity
- From Blaze to Buck2 - A Brief History of Monorepo Build Systems
- History and future of Infrastructure as Code
- Semantic Versioning Will Not Save You
- Solving Hierarchical Tags using Nested Sets
- Tools for better thinking
- What a good debugger can do
- When to use Bazel
- 10 Tips for Building Resilient Payment Systems
- A Bluffers Guide to CRDTs in Riak
- A Tale of Two Dimensions
- An Interactive Intro to CRDTs
- Applied Monotonicity: A Brief History of CRDTs in Riak
- Cache made consistent
- Chain replication : how to build an effective KV-storage (part 1/2)
- Cola: a text CRDT for real-time collaborative editing
- Conflict-free Replicated Data Types
- CRDTs go brrr
- Distributed Counter System Design
- Garbage Collected CRDTs on the Web
- I'm All-In on Server-Side SQLite
- Making CRDTs 98% More Efficient
- Microservice Architecture Pattern: Saga
- Modern-Day Architecture Design Patterns for Software Professionals
- Redis, Kafka or RabbitMQ: Which MicroServices Message Broker To Choose?
- Selected Sequence CRDTs
- The Inner Workings of Distributed Databases
- The Seven Most Classic Patterns for Distributed Transactions
- You Want Modules, Not Microservices
- Converting Integers to Floats Using Hyperfocus
- Gallery of Processor Cache Effects
- GCC undefined behaviors are getting wild
- GPU programming
- GPS
- Handles are the better pointers
- How Doom Fire was Done
- The Free Lunch Is Over: A Fundamental Turn Toward Concurrency in Software
- The legend of "x86 CPUs decode instructions into RISC form internally"
- Ubershaders: A Ridiculous Solution to an Impossible Problem
- WebAssembly's post-MVP future: A cartoon skill tree
- Why x86 Doesn’t Need to Die
- A Conspiracy To Kill IE6
- Biggest Y Combinator Failed Startups
- Big Tech’s Biggest Bets (Or What It Takes to Build a Billion-User Platform)
- Inside Elon Musk’s first meeting with Twitter employees
- List of 2024 Leap Day Bugs
- Making Crash Bandicoot
- New Breakthrough Brings Matrix Multiplication Closer to Ideal
- Programming in 1987 Versus Today
- Story: Redis and its creator antirez
- Stiff Asks, Great Programmers Answer
- The Fall of Stack Overflow, Explained
- The rise and fall of InVision
- The Saga of the Closure Compiler, and Why TypeScript Won
- The text file that runs the internet
- The untold Story of SQLite With Richard Hipp
- This is not your grandfather’s Perl
- Unladen Swallow Retrospective
- What we can learn from “_why”, the long lost open source developer
- What's worked in Computer Science: 1999 v. 2015
- Why Facebook doesn’t use Git
- A Collection of O'rly book Covers
- Dear Google Cloud: Your Deprecation Policy is Killing You
- Expert Excuses for Not Writing Unit Tests
- Golang is 𝘼𝙡𝙢𝙤𝙨𝙩 Perfect
- Golang is not a good language
- Haskell Researchers Announce Discovery of Industry Programmer Who Gives a Shit
- I Quit my Programmer Job to Become a Chicken
- I ****ing hate Science
- Introduction to Abject-Oriented Programming
- Nothing has ever angered me more than The Google Play Team
- Open Source is Not About You
- Manifesto for Half-Arsed Agile Software Development
- Re: clean up kernel_{read,write} & friends v2
- React I Love You, But You're Bringing Me Down
- Reflecting on 18 years at Google
- The Future of discord.py
- The Javascript "ecosystem" is a hot mess and so is software development in general
- The Tao of Programming
- This is my thinly veiled attempt to get you to use a library I wrote.
- Weird architectures weren't supported to begin with
- Why we at $FAMOUS_COMPANY Switched to $HYPED_TECHNOLOGY
- Best Practices for REST API Design
- How Did We Get Here? - Dive into HTML5
- How Did REST Come To Mean The Opposite of REST?
- HTTP/2 and HTTP/3 explained
- Is WebAssembly the return of Java Applets & Flash?
- Temporal API is Awesome
- The HTTP QUERY Method
- Understanding and implementing rate limiting in Node.js
- Weird things engineers believe about Web development
- Where are IPv3 and IPv5?
- Why is DNS still hard to learn?
- GPG And Me
- Memory Safe Languages in Android 13
- Secure by Design: Google’s Perspective on Memory Safety
- The PGP Problem
- Top Mental Health and Prayer Apps Fail Spectacularly at Privacy, Security
- What’s the matter with PGP?
- Zanzibar: Google’s Consistent, Global Authorization System
- A response to "Erlang - overhyped or underestimated"
- A taste of Coq and correct code by construction
- Being Popular
- Blogging about Midori
- Crafting Interpreters
- C++ is the next C++
- Does Go Have Subtyping?
- EXCEPTION HANDLING: A FALSE SENSE OF SECURITY
- Flattening ASTs (and Other Compiler Data Structures)
- Generics can make your Go code slower
- Go: the Good, the Bad and the Ugly
- I want off Mr. Golang's Wild Ride
- Make Invalid States Unrepresentable
- My Reaction to Dr. Stroustrup’s Recent Memory Safety Comments
- Old Neglected Theorems Are Still Theorems
- Revisiting Prechelt’s paper and follow-ups comparing Java, Lisp, C/C++ and scripting languages
- Should You Use Upper Bound Version Constraints?
- So, You Want To Write Your Own Language?
- Structured Concurrency Anniversary
- The Heart of a Language Server
- The Non-Productive Programmer (NPP)
- V Language Review (2023)
- Which Interpreters are Faster, AST or Bytecode?
- Why nullable types
- Advantages of Function Programming
- Monads For The Rest Of Us
- Reducing bugs with tight types
- Why Functional Programming Matters
- Circumventing the JVM's bytecode verifier
- Don’t call it a comeback: Why Java is still champ
- Finalizing the Foreign APIs
- GraalVM at Facebook
- How To Do Logging In Java
- Isolates and Compressed References: More Flexible and Efficient Memory Management via GraalVM
- I've promised myself never to use Gradle
- Overhead of Returning Optional Values in Java and Rust
- Java is Still Free
- Java Objects Inside Out
- JDK 17 G1/Parallel GC changes
- JVM Advent Calendar: A Beginner's Guide to Java Agents
- JVM Anatomy Quarks
- JVM Internals
- My final take on Gradle (vs. Maven)
- On the Performance of User-Mode Threads and Coroutine
- Phantom types in Java
- Pros and Cons for Using GraalVM Native-Images
- State of Valhalla
- String Tapas Redux
- Using Java's Project Loom to build more reliable distributed systems
- Virtual Threads: New Foundations for High-Scale Java Applications
- What About the Performance of Java 8 Lambdas
- What is JEP-303 or reinventing
invokedynamic
- Asynchronous clean-up
- C++ is faster and safer than Rust: benchmarked by Yandex
- Fearless Concurrency with Rust
- How Rust went from a side project to the world’s most-loved programming language
- How to write really slow Rust code
- Rust has a small standard library (and that's ok)
- The Future is Rusty
- The Rust I Wanted Had No Future
- This isn't the way to speed up Rust compile times
- Using Rust at a startup: A cautionary tale
- What is Rust and why is it so popular?
- 15 Years of Concurrency
- Beautiful Concurrency
- Beyond Exception Handling: Conditions and Restarts
- Challenging LR Parsing
- Compile-time and short-circuit evaluation
- Compiler Optimizations Are Hard Because They Forget
- Considerations for programming language design: a rebuttal
- Invariants: A Better Debugger?
- Literate programming: Knuth is doing it wrong
- Notes on structured concurrency, or: Go statement considered harmful
- Meta-compilation
- Reducing boilerplate in finally tagless style
- Programming Paradigms for Dummies: What Every Programmer Should Know
- Representing Heterogeneous Data
- The Impoliteness of Overriding Methods
- The Problem with Threads
- The Trouble with Checked Exceptions A Conversation with Anders Hejlsberg, Part II
- What Color is Your Function?
- Types vs Sets
- Agile and the Long Crisis of Software
- Best Books For The Inquisitive Software Engineer
- Bullshit Software Projects
- How I learned to turn Impostor Syndrome into an Advantage - The Impostor's Advantage
- Imaginary Problems Are the Root of Bad Software
- Magnitudes of exploration
- McKinsey Developer Productivity Review
- Measuring developer productivity? A response to McKinsey
- New grad vs Senior Developer
- The care and feeding of software engineers (or, why engineers are grumpy)
- The Differences Between a Junior, Mid-Level, and Senior Developer
- The forgotten mistake that killed Japan’s software industry
- The Worst Programmer I know
- What’s the difference between software engineering and computer science degrees?
- What Breaks Google?
- Why Twitter Didn’t Go Down: From a Real Twitter SRE
- Big Ball of Mud
- Collection Pipelines
- Feature Toggles (aka Feature Flags)
- Kernighan and Pike were right: Do one thing, and do it well
- Scaling microservices with gRPC: part one
- When to not use SOLID principles
- Why I don’t buy “duplication is cheaper than the wrong abstraction”
- Write code that is easy to delete, not easy to extend.
- Behind the scenes of Singapore’s nationwide ticket operating system for the National Day Parade
- Cache made consistent
- How Discord Supercharges Network Disks for Extreme Low Latency
- How to shuffle songs
- How we store and process millions of orders daily
- Integrating Rust and C++ in Firefox
- Meta's serverless platform processes trillions of function calls a day
- Post-Incident Review on the Atlassian April 2022 outage
- Ready for changes with Hexagonal Architecture
- Scaling GraphQL at PayPal
- Seeing through hardware counters: a journey to threefold performance increase
- Taming Go’s Memory Usage, or How We Avoided Rewriting Our Client in Rust
- TAO: The power of the graph
- The Story of the PS2’s Backwards Compatibility From the Engineer Who Built It
- Uber's rewrite story (from different perspectives)
- UK air traffic control meltdown
- Upgrading GitHub to Ruby
- Why We Started Putting Unpopular Assets in Memory
- 10 Proven Techniques for More Effective Code Reviews
- 17 Mental Models, biases and fallacies that Software Developers should know
- 3 tribes of programming
- 20 Things I’ve Learned in my 20 Years as a Software Engineer
- A Generation Lost in the Bazaar
- A layman's guide to thinking like the self-aware smol brained
- Cargo Cult Software Engineering
- Choose Boring Technology
- Common Bugs in Writing
- Documentation unit tests
- Empirically supported code review best practices
- Evidence Based Scheduling
- Famous Laws of Software Development
- Five Worlds
- Google's technical writing blog
- How does one get as close as possible to mastering software engineering?
- How Google takes the pain out of code reviews, with 97% dev satisfaction
- How to Make Your Code Reviewer Fall in Love with You
- How to Thrive as an Average Programmer
- Keeping code simple: moving fast by avoiding over-engineering
- Investing in Internal Documentation: A Brick-by-Brick Guide for Startups
- Lessons from 6 software rewrite stories
- Pair Programming
- Random Thoughts 15 Years into Software Engineering
- Software engineering practices
- The 10x Programmer Myth
- The Power of Ten – Rules for Developing Safety Critical Code
- The Pragmatic Engineer Test: 12 Questions on Engineering Culture
- The Joel Test: 12 Steps to Better Code
- The Twelve-Factor App
- Things they didn’t teach you about Software Engineering
- Top Five (Wrong) Reasons You Don’t Have Testers
- What distinguishes great software engineers?
- What we talk about when we talk about impostor syndrome
- 10 Papers Every Developer Should Read (At Least Twice)
- Falsehoods Programmer Believe About Addresses
- Falsehoods Programmers Believe About Email
- Falsehoods Programmers Believe About Names – With Examples
- Falsehoods programmers believe about time zones
- Godot binding system explained
- Godot is not the new Unity - The anatomy of a Godot API call
- How To Ask Questions The Smart Way
- It takes a PhD to develop that
- It's probably time to stop recommending Clean Code
- Linguistic Antipatterns
- Marketing for maintainers: Promote your project to users and contributors
- Patterns in confusing explanations
- Please Don't Learn to Code
- Programming Sucks
- Prompt injection explained, with video, slides, and a transcript
- Recommended Reading for Developers
- Second Part: The SLOs Playbook
- Small Pleasures of Programming
- Stop Optimizing for Tutorials
- Teach Yourself Programming in Ten Years
- The Decline of Usability
- The silent majority
- The Two Generals Problem
- Timezones
- Whatever happened to programming?
- Why the C Language Will Never Stop You from Making Mistakes