Software design
23 articles in this category
Inheritance is a Relic: Composition Over Class Hierarchies
Object-oriented programming taught us that code reuse is achieved through class inheritance. In practice, deep inheritance hierarchies create fragile base classes, high coupling, and rigid domain structures. It is time to abandon inheritance and embrace composition.
The Fallacy of DRY: Why You Should Write Duplicated Code First
Don't Repeat Yourself (DRY) is one of the first design principles programmers learn. But applying it too early creates tightly coupled, hyper-flexible abstractions that crumble under the weight of changing requirements. Write duplicated code until the structure reveals itself.
Why Clean Architecture is a Maintainability Nightmare
Robert C. Martin's 'Clean Architecture' promises to decouple your business logic from external frameworks and databases. In practice, it leads to a sprawling wasteland of boilerplate, interface layers that pass data straight through, and excessive mapping functions. Here's why YAGNI should trump architecture dogmatism.
Why ORMs are the Worst Anti-Pattern in Modern Backend Development
Object-Relational Mapping (ORM) tools promise to free developers from SQL. In exchange, they introduce the N+1 query problem, hide database performance realities behind black-box abstractions, and create models that couple application state to database schemas. It's time to write SQL again.
Microservices: The Great Architecture Grift of the 2010s
The industry fell head-over-heels for microservices, believing they would solve all development bottlenecks. Instead, we traded in-process function calls for unreliable network requests, simple joins for distributed transactions, and single deployments for orchestration nightmares. The monolith was right all along.
Python Dataclasses vs Pydantic: The Complete Production Guide
A comprehensive technical reference covering ALL features of Python dataclasses and Pydantic v2+. Learn when to use each, performance trade-offs, validation patterns, serialization mechanics, and production patterns for senior engineers.
Clean Code: The Cult of Dogma and Why Your Abstractions Are Probably Wrong
Robert C. Martin's Clean Code shaped a generation of developers, but its dogmatic rules about tiny functions, obsessive DRY, and terrible example code have caused more harm than good. Here's what the book got right, what it got catastrophically wrong, and what to read instead.
Hexagonal Architecture: Why Your Domain Logic Shouldn't Know About Your Database
Stop letting frameworks dictate your architecture. Learn how Hexagonal Architecture (Ports & Adapters) isolates business logic from infrastructure, makes testing trivial, and lets you swap databases without rewriting code.