_outlook

Unix Philosophy

The Unix philosophy emphasizes building simple, compact, clear, modular, and extensible code that can be easily maintained and repurposed by developers other than its creators.

_Modularity:
Write simple parts connected by clean interfaces.

_Clarity:

Clarity is better than cleverness.

_Composition:

Design programs to be connected to other programs.

_Separation:

Separate policy from mechanism; separate interfaces from engines.

_Simplicity:

Design for simplicity; add complexity only where you must.

_Parsimony:

Write a big program only when it is clear by demonstration that nothing else will do.

_Transparency:

Design for visibility to make inspection and debugging easier.

_Robustness:

Robustness is the child of transparency and simplicity.

_Representation:

Fold knowledge into data so program logic can be stupid and robust.

_Least Surprise:

In interface design, always do the least surprising thing.

_Silence:

When a program has nothing surprising to say, it should say nothing.

_Repair:

When you must fail, fail noisily and as soon as possible.

_Economy:

Programmer time is expensive; conserve it in preference to machine time.

_Rule of Generation:

Avoid hand-hacking; write programs to write programs when you can.

_Optimization:

Prototype before polishing. Get it working before you optimize it.

_Diversity:

Distrust all claims for “one true way”.

_Extensibility:

Design for the future, because it will be here sooner than you think.