“The best modules are those that provide a lot of functionality without having to know much about the rest of the world.”
John Ousterhout used this sentence in a Stanford software design lecture while discussing module depth and information hiding. A module is not valuable merely because code has been divided into files or classes. Its value comes from the relationship between the capability it offers and the knowledge it demands from callers. A deep module presents a relatively simple interface while handling substantial complexity internally. A shallow one exposes nearly as much complexity as it contains, forcing every user to understand options, ordering rules, failure cases, or internal structure before accomplishing a small task.
The phrase “rest of the world” points to coupling. When a module depends on many distant details, changes propagate through the system and local reasoning becomes difficult. Good modules know only what they need, and they prevent callers from depending on decisions that should remain private. This does not mean every interface should be tiny or every component independent. Some domains are inherently complex, and hiding an essential choice can produce surprise. The goal is to concentrate complexity where it can be managed, expose concepts that users truly need, and avoid making incidental implementation details part of a permanent contract.
Examples appear throughout software. A storage abstraction can handle buffering, retries, and file formats while exposing a small set of durable operations. A user-interface component can manage focus and accessibility without requiring each screen to recreate those rules. Conversely, a wrapper that renames another function but preserves all of its parameters adds a layer without adding abstraction. Ousterhout’s measure is therefore practical: count not only lines of code but also the cognitive load transferred across a boundary. A useful module reduces the amount of system state that a developer must hold in mind.
The lesson has grown more important as dependencies multiply. Cloud SDKs, frameworks, AI services, and internal platforms promise leverage, yet a poorly designed interface can spread vendor details and operational assumptions across an entire codebase. Deep modules create places where those assumptions can be controlled, tested, and changed. They also improve collaboration because teams can work from stable contracts instead of continuous knowledge of one another’s internals. Modularity is not fragmentation for its own sake. It is the deliberate construction of boundaries that let people use powerful behavior without importing the whole system’s complexity into every decision. When a boundary repeatedly leaks special cases, that leakage is evidence to redesign the abstraction rather than teach every caller another exception.
Ousterhout’s Stanford software design material uses the idea of deep modules to evaluate abstraction quality. The comparison is between functionality provided and interface complexity exposed.
The lecture treats information hiding as central: design decisions likely to change should remain inside a module rather than becoming knowledge required by every caller.
A strong module reduces how much of the wider system a caller must understand. Its boundary concentrates complexity instead of merely moving code into another file.
Simplicity should not conceal choices users genuinely need to control. The interface must expose essential domain concepts while hiding incidental mechanisms and volatile details.
Modern applications depend on frameworks, cloud APIs, and external services. Carefully designed modules keep those dependencies from leaking assumptions throughout the codebase.
Deep boundaries also support teams. Stable contracts let people change implementations independently and reason locally, reducing the coordination cost of maintaining large systems.
Explore more "Quotes of The Day"
Discover more notable quotes from influential voices across politics, science, business, technology, sports, and culture. Each quote offers insight into how ideas, beliefs, and decisions shape the world around us.