Unix philosophy originated from Ken Thompson’s early thinking on how to design a small but useful operating system with clear service interfaces. As people learn how to make the Thompson design the most effective, Unix culture was born and grew, and drew nourishment from various sources.
The Unix philosophy is not a formal design method. It never claims in theory that it can produce better software. You can’t expect it to use poor project management and cheap programmers to make a very innovative and reliable software in a short period of time.
Module principle: use simple interfaces to combine simple components
The principle of clarity: clarity is better than ingenuity
Combination principle: consider splicing and combination when designing
Separation principle: separation of strategy and mechanism, separation of interface and engine
Principle of conciseness: the design should be concise, and the complexity can be as low as possible
The principle of parsimony: Don’t write huge programs unless there is no other way
The principle of transparency: the design must be visible for review and debugging
Robustness principle: Robustness comes from transparency and simplicity
Representation principle: Fold knowledge into data to make logic simple and robust
Popular principles: interface design to avoid unconventional
The principle of silence: if a program has nothing to say, keep silent
Remedy principle: When an exception occurs, immediately exit and give a sufficient amount of error information
Economic principle: It’s better to spend a minute for a machine than a second for a programmer
Generation principle: Avoid manual hacks, try to write programs to generate programs
Optimization principle: You must have a prototype before carving, and learn to walk before running
The principle of diversity: never believe in the assertion of the so-called “one way”
Expansion principle: Design with a focus on the future, the future is always faster than expected