# Hyrum's Law  ## Metadata - Author: [[hyrumslaw.com]] - Full Title: Hyrum's Law - Category: #articles - Document Tags: #keep - Source: reader - Last Highlighted: 2025-02-12 17:15:28.056507+00:00 - URL: https://www.hyrumslaw.com/ ## Summary Over the past couple years of doing low-level infrastructure migrations in one of the most complex software systems on the planet, I’ve made some observations about the differences between an interface and its implementations. ## Highlights - With a sufficient number of users of an API, it does not matter what you promise in the contract: all observable behaviors of your system will be depended on by somebody. ([View Highlight](https://read.readwise.io/read/01jkxj61jdtdf8gj837ch0e4vk)) - We typically think of the interface as an abstraction for interacting with a system (like the steering wheel and pedals in a car), and the implementation as the way the system does its work (wheels and an engine). ([View Highlight](https://read.readwise.io/read/01jkxjfdw2xem8n6aqd2t38bex)) - In practice, this theory breaks down as the use of a system grows and its users start to rely upon implementation details intentionally exposed through the interface, or which they divine through regular use. Spolsky’s “Law of Leaky Abstractions” embodies consumers’ reliance upon internal implementation details. ([View Highlight](https://read.readwise.io/read/01jkxjfxxd9kqy2gwsrwx70mds)) - Implicit interfaces result from the organic growth of large systems, and while we may wish the problem did not exist, designers and engineers would be wise to consider it when building and maintaining complex systems. So be aware of how the implicit interface constrains your system design and evolution, and know that for any reasonably popular system, the interface reaches much deeper than you think. ([View Highlight](https://read.readwise.io/read/01jkxjgkf45atv3cqwdrdb9e9j)) - Obligatory XKCD: [https://xkcd.com/1172/](https://xkcd.com/1172/) ([View Highlight](https://read.readwise.io/read/01jkxjh4nmwzxgyah55axez68q)) ## New highlights added March 14, 2025 at 10:03 PM - With a sufficient number of users of an API, it does not matter what you promise in the contract: all observable behaviors of your system will be depended on by somebody. ([View Highlight](https://read.readwise.io/read/01jkxj61jdtdf8gj837ch0e4vk)) - We typically think of the interface as an abstraction for interacting with a system (like the steering wheel and pedals in a car), and the implementation as the way the system does its work (wheels and an engine). ([View Highlight](https://read.readwise.io/read/01jkxjfdw2xem8n6aqd2t38bex)) - In practice, this theory breaks down as the use of a system grows and its users start to rely upon implementation details intentionally exposed through the interface, or which they divine through regular use. Spolsky’s “Law of Leaky Abstractions” embodies consumers’ reliance upon internal implementation details. ([View Highlight](https://read.readwise.io/read/01jkxjfxxd9kqy2gwsrwx70mds)) - Implicit interfaces result from the organic growth of large systems, and while we may wish the problem did not exist, designers and engineers would be wise to consider it when building and maintaining complex systems. So be aware of how the implicit interface constrains your system design and evolution, and know that for any reasonably popular system, the interface reaches much deeper than you think. ([View Highlight](https://read.readwise.io/read/01jkxjgkf45atv3cqwdrdb9e9j)) - Obligatory XKCD: [https://xkcd.com/1172/](https://xkcd.com/1172/) ([View Highlight](https://read.readwise.io/read/01jkxjh4nmwzxgyah55axez68q)) ## New highlights added March 15, 2025 at 8:44 AM - With a sufficient number of users of an API, it does not matter what you promise in the contract: all observable behaviors of your system will be depended on by somebody. ([View Highlight](https://read.readwise.io/read/01jkxj61jdtdf8gj837ch0e4vk)) - We typically think of the interface as an abstraction for interacting with a system (like the steering wheel and pedals in a car), and the implementation as the way the system does its work (wheels and an engine). ([View Highlight](https://read.readwise.io/read/01jkxjfdw2xem8n6aqd2t38bex)) - In practice, this theory breaks down as the use of a system grows and its users start to rely upon implementation details intentionally exposed through the interface, or which they divine through regular use. Spolsky’s “Law of Leaky Abstractions” embodies consumers’ reliance upon internal implementation details. ([View Highlight](https://read.readwise.io/read/01jkxjfxxd9kqy2gwsrwx70mds)) - Implicit interfaces result from the organic growth of large systems, and while we may wish the problem did not exist, designers and engineers would be wise to consider it when building and maintaining complex systems. So be aware of how the implicit interface constrains your system design and evolution, and know that for any reasonably popular system, the interface reaches much deeper than you think. ([View Highlight](https://read.readwise.io/read/01jkxjgkf45atv3cqwdrdb9e9j)) - Obligatory XKCD: [https://xkcd.com/1172/](https://xkcd.com/1172/) ([View Highlight](https://read.readwise.io/read/01jkxjh4nmwzxgyah55axez68q)) ## New highlights added June 20, 2025 at 4:00 PM - With a sufficient number of users of an API, it does not matter what you promise in the contract: all observable behaviors of your system will be depended on by somebody. ([View Highlight](https://read.readwise.io/read/01jkxj61jdtdf8gj837ch0e4vk)) - We typically think of the interface as an abstraction for interacting with a system (like the steering wheel and pedals in a car), and the implementation as the way the system does its work (wheels and an engine). ([View Highlight](https://read.readwise.io/read/01jkxjfdw2xem8n6aqd2t38bex)) - In practice, this theory breaks down as the use of a system grows and its users start to rely upon implementation details intentionally exposed through the interface, or which they divine through regular use. Spolsky’s “Law of Leaky Abstractions” embodies consumers’ reliance upon internal implementation details. ([View Highlight](https://read.readwise.io/read/01jkxjfxxd9kqy2gwsrwx70mds)) - Implicit interfaces result from the organic growth of large systems, and while we may wish the problem did not exist, designers and engineers would be wise to consider it when building and maintaining complex systems. So be aware of how the implicit interface constrains your system design and evolution, and know that for any reasonably popular system, the interface reaches much deeper than you think. ([View Highlight](https://read.readwise.io/read/01jkxjgkf45atv3cqwdrdb9e9j)) - Obligatory XKCD: [https://xkcd.com/1172/](https://xkcd.com/1172/) ([View Highlight](https://read.readwise.io/read/01jkxjh4nmwzxgyah55axez68q))