I keep coming back to the Unix philosophy: do one thing well, compose freely, use text streams.
This is not nostalgia. It is a design principle that scales from command-line tools to library APIs to distributed systems. I have been running Linux for a long time, and the tools that last are the ones that follow this pattern.
What Makes a Good Tool
The best tools I have built or used share these properties:
- Single responsibility. Clear purpose, no feature creep.
- Composable. Works with other tools via clean interfaces.
- Transparent. Behavior is predictable and debuggable.
- Minimal. No unnecessary dependencies or coupling.
The grep | sort | uniq pipeline works because each piece does exactly one thing and communicates through a universal interface (text streams). Twenty years later I still reach for these tools first.
Why This Matters for Libraries
When I design APIs, I think in Unix terms:
- Small, focused functions that do one thing
- Pipeable operations where output of one becomes input to another
- Plain data over complex objects when possible
- Fail explicitly rather than silently
A library with twelve composable functions is more useful than one with three monolithic ones. The user can combine the pieces in ways I did not anticipate. That is the point.
The Deeper Principle
The Unix philosophy is really about respecting the user's intelligence. Do not hide complexity behind magic. Give them primitives they can combine.
This is how tools become timeless. awk is from 1977 and I used it yesterday.
