Beyond the Banana: Mastering Precision for Clean, Maintainable Code

Avoiding the Gorilla and the Jungle

A common architectural trap is requesting more data than a function actually needs. This violates the Law of Demeter (the principle of least knowledge). For example, if a function needs a coordinate but you pass it an entire Location object containing metadata, timestamps, and history, you've over-coupled that function. You cannot use it elsewhere without providing that heavy object. As Joe Armstrong, the creator of

, famously noted, you wanted a banana, but you got a gorilla holding the banana and the entire jungle. The solution is to pass the specific sub-component—like a GeoLocation—to keep the function focused and decoupled.

The Logic of Strict Input and Single-Type Returns

Functions that accept a "grab bag" of types (Union types like str | int | bytes) often seem convenient but lead to internal complexity. These functions require internal if/else logic to handle every variation, complicating your unit tests. Instead, strive for strict input types. If you need convenience, use factory methods like from_int or from_string to convert data before it hits your core logic.

Similarly, return types should be predictable. Returning a URI object or a bool (for failure) forces the caller to write boilerplate error handling everywhere. A more precise approach uses exceptions. By raising a custom exception for invalid data and returning only the success type, you simplify the calling code from a dozen lines of checks to a clean, three-line execution flow.

Leveraging Generic Parameters and Specific Returns

While inputs should be strict in value, they should be generic in capability. In

, instead of requiring a list, you should often require an Iterable or Sized type. This allows your function to accept tuples, sets, or even custom objects without changing a line of code. However, the return type should remain highly specific. By returning a list rather than a generic Iterable, you tell the caller exactly what methods (like .append() or indexing) are available. This asymmetry—generic inputs and specific outputs—is a hallmark of professional-grade software design.