Pante's Reading List

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.

Sections

• Blogs
  • Companies
  • Personal
• 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
  • Functional Programming
  • Java/JVM
  • Rust
  • Theory
• Software Engineering
  • Architecture/Design Patterns
  • Code Studies
  • Practices & Processes
• Uncategorized

Blogs

Companies

• Cloudflare's blog
• Discord's Blog
• Facebook's blog
• Github's Blog
• Netflix Technology Blog
• Riot Game's Blog
• Shopify's Blog

Personal

• 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

Career

• 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

Data Structures & Algorithms

• 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
  • Part 1
  • Part 2
  • Part 3
• Parsing: The Solved Problem That Isn't
• The Piece Table
• Unicode is harder than you think

Data Design/Databases

• 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

Deep dives/Performance/Retrospectives

• 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

Developer Experience/Tooling

• 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

Distributed Systems/System Design

• 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

Hardware/Low Level

• 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

History/News

• 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
  • Part 1
  • Part 2
  • Part 3
  • Part 4
  • Part 5
  • Part 6
• 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

Humour/Rants/Satire

• 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

Networking/Web

• 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?

Mobile Development

• Mobile is actually pretty hard.
• Playing haptics

Privacy & Security

• 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

Programming Languages/Theory

• 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
  • Original article
  • Lies we tell ourselves to keep using Golang
  • I won free load testing
• 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

Functional Programming

• Advantages of Function Programming
• Monads For The Rest Of Us
• Reducing bugs with tight types
• Why Functional Programming Matters

Java/JVM

• 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
  • 2020 Part 1
  • 2020 Part 2
  • 2021 Part 1
  • 2021 Part 2
  • 2021 Part 3
• 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

Rust

• 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
  • Part 1
  • Part 2
• 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?

Theory

• 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

Software Engineering

• 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

Architecture/Design Patterns

• 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.

Case Studies

• 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)
  • Uber's Crazy YOLO App Rewrite, From the Front Seat
  • McLaren Stanley's account
• UK air traffic control meltdown
• Upgrading GitHub to Ruby
• Why We Started Putting Unpopular Assets in Memory

Practices & Processes

• 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

Uncategorized

• 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