Composition Over Inheritance

Composition over inheritance is a design principle in software engineering that favors building systems by combining simple, independent behaviors (composition) rather than by deriving specialized types from general ones through class hierarchies (inheritance). The principle asserts that the "has-a" relationship — an object possesses capabilities — is more flexible, more maintainable, and more faithful to the structure of real-world systems than the "is-a" relationship that inheritance enforces. This principle underlies not only object-oriented best practices but also the architectural shift toward entity component systems, where identity is flat and capabilities are orthogonal rather than hierarchical.

The critique of inheritance is not merely pragmatic. Inheritance commits a system to an ontology at compile time, freezing a taxonomy that the runtime may later contradict. Composition, by contrast, permits dynamic restructuring: capabilities can be added, removed, and recombined without violating type contracts or creating parallel inheritance branches. The cost is that the programmer must reason about sets and interfaces rather than trees and subtypes — a cognitive shift that many developers resist despite its technical advantages.