Blog
Thoughts on software engineering, system design, and the occasional rant about the state of modern tech
The Mechanical Sympathy of LLMs: Why Your Prompt Engineering is (Probably) Bullshit
Stop treating LLMs like a black box. To truly master them, you need to stop whispering prompts and start developing mechanical sympathy for the machine.
The Coming Death of Denormalization: How Differential Dataflow Will Save Us All
Or: How I Learned to Stop Worrying and Love the Incremental Computation. A deep dive into why manual denormalization is dying and how Differential Dataflow will revolutionize database performance.
FastAPI: Why Minimalist Frameworks Maximize Your Work
After watching too many projects wish they'd just used Django when hitting production requirements, I need to share some observations.
Everyone is Customer Success
Why your startup's org chart is holding you back and why everyone from the CTO to the intern should be directly connected to customer outcomes instead of hiding behind layers of product managers.
Lambda Considered Harmful
Why your five-person startup probably doesn't need to architect its cron jobs like a FAANG company having a seizure. A love letter to the humble job queue.
Just Fucking Use Heroku
A rant about why your 5-person B2B SaaS startup has no business spending weeks architecting a complex Kubernetes cluster on AWS when Heroku exists.
Stop Pretending the Central Limit Theorem Makes Your Data Normally Distributed
Everyone loves to pretend their data is normal when it's not. Here's why the Central Limit Theorem fails in production, why n=30 is a lie, and why your averages are hiding disasters.
A Crash Course in Scikit-learn: Your First Steps in Machine Learning
A beginner-friendly guide to scikit-learn, covering core concepts, your first model, and common pitfalls.
The Butterfly Effect: Unpacking the Second-Order Consequences of Code
A simple line of code can have unforeseen consequences that ripple through society. This post explores the fascinating, unpredictable, and powerful second-order effects of seemingly small engineering decisions.
The Law of Leaky Abstractions: From Code to the Cosmos
Joel Spolsky's Law of Leaky Abstractions is more than a software development rule; it's a fundamental principle for navigating the complexities of the modern world. We explore how this law applies everywhere, from TCP/IP stacks to the legal system and beyond.
A Curated List of Recommended Books & Resources
A curated list of recommended books, articles, blogs, and more, grouped by category. Resources feature icons indicating their type.
Measuring the Unmeasurable: A Guide to Developer Productivity
A comprehensive guide to developer productivity covering ethics, economics, strategies, and the future of LLM-based measurement.
A Complete History of JavaScript Frameworks in the Modern Age, from the Perspective of a Confused Backend Developer
A backend developer's yearly attempt to understand the chaotic world of JavaScript frameworks, state management, and meta-frameworks.
The Anatomy of an Engineering Decision: A Guide to Trade-offs
In software engineering, there are no 'correct' answers, only a spectrum of trade-offs. This post dissects the thought process behind making deliberate, reasoned engineering decisions.
PyArrow, Polars, Pandas 3.0, and DuckDB: The Small-Data Revolution
Almost everybody's data fits on a laptop. The new generation of single-machine tools—PyArrow, Polars, DuckDB, and Pandas 3.0—are making distributed systems obsolete for 99% of companies. Here's why the small-data revolution changes everything.
Property-Based Testing: Let Your Computer Find Bugs You Can't Imagine
Explore how property-based testing with Python's Hypothesis library can uncover edge cases and bugs that traditional example-based tests miss, transforming the way you think about testing.
The Engineer's Complete Guide to Evaluating Startup Opportunities
A comprehensive framework for engineers to evaluate startup opportunities, covering everything from idea validation to team assessment and cultural red flags.
Rule 0 of Negotiation: Don't Enter a Fight You Can't Walk Away From
Everyone knows Rule #1: first person to say a number loses. But there's a more important rule that comes before it—Rule 0. Violate this one, and you're not negotiating anymore. You're being extorted.
The Nvidia Bubble: Why a $3 Trillion Valuation Defies Logic
An analysis of why Nvidia's meteoric rise to a $3 trillion valuation represents one of the most disconnected valuations in modern market history, examining the unsustainable margins, inevitable competition, and undervalued alternatives.
A Tribute to My Parents' Perseverance: From Bangladesh to the Bronx
The remarkable story of how my parents came to America with $20 and built a life through sheer determination and sacrifice.
The Ultimate DRF Spectacular Guide: Every Feature in One ViewSet
A comprehensive example showcasing every single feature of drf-spectacular in one exhaustively annotated ViewSet. The documentation example the official docs should have included.
Your Startup Doesn't Need 47 Lambda Functions (A Monolith Would Be Fine)
An epidemic of serverless overengineering is plaguing startups. Here's why your 200-user startup doesn't need the same architecture as Netflix.
Oracle: The Real Evil Empire
While other tech giants pretend to innovate, Oracle has perfected a more sinister art: buying companies with trapped customers and extracting every possible dollar. It's not a technology company—it's a financial parasite that happens to own software.
The Actor Model and What It Can Teach Us About Human Organizational Structures
How a 1973 computer science concept accidentally explains why most organizations fail and how the best ones succeed
Adding Permissions to Auth0 ID Tokens via Actions
Learn how to dynamically add user permissions to Auth0 ID tokens using post-login Actions.
The Python Features You're Not Using (But Should Be)
From the walrus operator to pattern matching, discover Python's most underused features that can make your code more elegant, efficient, and Pythonic. These aren't just neat tricks—they're powerful tools that seasoned developers reach for.
Ruby: The Language That Peaked in 2007 and Nobody Told It
A brutally honest look at Ruby's fall from grace - from 'developer happiness' to 'developer unemployment line.' How Rails' favorite language became a cautionary tale about prioritizing syntax sugar over everything else.
Brooks's Law: Why Adding People to Late Projects Makes Them Later
The counterintuitive principle that adding manpower to a late software project makes it later, and why it still matters nearly 50 years later.
RocksDB: The Database Engine You've Never Heard Of (But Use Every Day)
RocksDB isn't just another database—it's the embedded storage engine powering everything from your browser to blockchain nodes to distributed SQL databases. Discover how Facebook's fork of LevelDB became the Swiss Army knife of modern data storage.
WTF is an LSM Tree? The Secret Sauce Behind Modern Databases
LSM trees are everywhere in modern databases—from RocksDB to Cassandra to ScyllaDB. But what exactly are they, and why have they become the go-to data structure for high-performance write-heavy workloads?
WTF Is a Y Combinator? (And Why Should You Care About Combinators)
The Y combinator isn't just some abstract mathematical curiosity—it's a fundamental building block that reveals deep truths about computation, recursion, and the nature of functions themselves.
ScyllaDB: The Monstrously Fast Wide-Column Database Redefining Performance
A deep dive into ScyllaDB's revolutionary architecture, when to use it over alternatives, and why it's redefining database performance expectations.
Haskell: The Language That's Been 'About to Go Mainstream' Since 1990
A humorous deep dive into why Haskell remains eternally 'five years away from mainstream adoption' - spoiler: it's not the job market, it's the language's fundamental disconnect from real-world programming needs.
LuaJIT: The One-Man Compiler That Embarrassed the Industry
How one developer created a JIT compiler so advanced it made Lua faster than Java, rivaled C, and became the foundation for critical infrastructure—then vanished, leaving behind a codebase too brilliant for anyone else to maintain.
C++: Death by a Thousand Features
A deep dive into how C++ became the programming language equivalent of a hoarder's house where every programming paradigm from the last 40 years has set up camp and refuses to leave.
JavaScript: The Pandemic That Escaped the Browser Quarantine
The horror story of how we let a language designed in 10 days become the foundation of our entire technological civilization. A rant about JavaScript's escape from the browser and its conquest of backend development.
The Holy Grail of Garbage Collection: Dissecting Azul's C4 Algorithm
An in-depth exploration of Azul Systems' revolutionary pauseless garbage collection algorithm that solved the decades-old problem of GC pauses.
The Abject Stupidity of Microservices
A deep dive into why microservices are often a disastrous choice, creating complex engineering problems to solve human ones.
Filters
Stats
Showing 38 of 38 posts