Real-world programming examples of the Unix philosophy

Question

What are some specific[1] real-world code[2]/design examples, personal anecdotes, mistakes learned (with more emphasis on personal anecdotes, mistakes learned instead of pointing out third-party software) that best illustrate the programming philosophy of Unix? For a start, here's Raymond's summarization of the philosophy from The Art of Unix Programming:

Rule of Modularity: Write simple parts connected by clean interfaces.

Rule of Clarity: Clarity is better than cleverness.

Rule of Composition: Design programs to be connected to other programs.

Rule of Separation: Separate policy from mechanism; separate interfaces from engines.

Rule of Simplicity: Design for simplicity; add complexity only where you must.

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

Rule of Transparency: Design for visibility to make inspection and debugging easier.

Rule of Robustness: Robustness is the child of transparency and simplicity.

Rule of Representation: Fold knowledge into data so program logic can be stupid and robust.

Rule of Least Surprise: In interface design, always do the least surprising thing.

Rule of Silence: When a program has nothing surprising to say, it should say nothing.

Rule of Repair: When you must fail, fail noisily and as soon as possible.

Rule of 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.

Rule of Optimization: Prototype before polishing. Get it working before you optimize it.

Rule of Diversity: Distrust all claims for “one true way”.

Rule of Extensibility: Design for the future, because it will be here sooner than you think.

[1]: just saying "Linux" (or Unix tools, or my pet project Foo) is not enough; what is it about Linux that makes it an example of the Unix programming philosophy? In a similar manner, just saying "Linux is modular" too is disingenuous; again - what makes linux follow the rule of modularity as listed here? (for eg: lkm, etc.) The devil is in the details.

[2]: This question is not about merely "code" examples as S.Lott seems to believe. The question clearly also states design, personal anecdotes and mistakes learned, with more emphasis on the later two (for which no answer has been given yet).

Answer 1

Since the Linux OS is a significant real world example of this, what more do you need? Other pieces of software that fix the Linux pattern? Most of the widely-used, very active open source projects that run under Linux fit this pattern. That's a lot of real-world examples.

Answer 2

Autotools. It's true. I'm sorry.

Answer 3

Dare I suggest Windows PowerShell? I believe it embodies the philosophy better than Unix itself. For those unfamiliar, here's what Wikipedia has to say about it: http://en.wikipedia.org/wiki/Windows_PowerShell

To summarize, it's designed to be an ecosystem of small objects that can all communicate with each other to perform complex tasks.

Answer 4

Try 'The UNIX Philosophy' by Mike Gancarz, rather than listening to ESR. In his book he mentions the 'MH' mail client:

http://rand-mh.sourceforge.net/

mh is a small series of programs you can use in conjunction with other unix utilities to read mail.

Check out the design of MH http://www.rand.org/pubs/notes/N3017/ And the manual http://www.rand.org/pubs/reports/R2367/

I'd also recommend Plan9 as a wonderful example of something more UNIX than UNIX. Everything is a file within plan9 and it.

Answer 5

To my mind, the highest ideal of UNIX programming is to have a bunch of very small programs who "do one thing well" and are composable, usually through PIPEs and usually processing data as text.

Other styles of programming also have this philosophy, albeit in different forms. OOP has the Single Responsibility Principle, functional programming has combinators, higher-order functions, monads, and so on. The Linux OS exhibits the UNIX philosophy quite well, particularly in the way it loads and unloads independent modules, but it has a reasonably large kernel at its core. GNU Hurd took the idea a step further and got rid of Linux's macrokernel core and attempted to produce an entire OS based on small, independent, cooperating parts, although Hurd itself never really took flight.

Concrete examples

In terms of examples of the UNIX philosophy, there are a few places to look. Good shell scripting practice should exhibit UNIX-foo, as should well written Emacs modes and some kernels -- try MINIX if you don't want something small and readable: http://www.minix3.org/source.html

For a medium-sized example of shell scripting, the BASH script in /etc/init.d/skeleton is a skeleton for a UNIX daemon and, to my mind, written with some clarity. You can read more about this here (with source): http://www-theorie.physik.unizh.ch/~dpotter/howto/

Some smaller examples of shell scripts, which (IMO) exhibit the UNIX philosophy, follow:

Get an accurate word count of a LaTeX document split over several files

detex mydocs/*.tex | wc -w

Check for large files in an SVN repo

svn status | awk '{print $2}' | xargs du | sort -n | tail

List files by modification date

find -type f -print0 | xargs -r0 stat -c %y\ %n | sort

With all of these examples we're just combining simple building blocks to produce a single result. You can find a whole bunch of scripts like this at http://www.commandlinefu.com

Answer 6

All Unix tools embody these ideas. Unix came first. The book came later. That should tell you something.

Answer 7

Git is an epitome of the software built with Unix philosophy.

On installing git, you install literally 100s of commands on to your system, of which most are called git-plumbing which git uses internally and 36 are the high level commands, called git-porcelain that abstract the plumbing usage and hides the implementation detail to (well, ostensibly) create good interface.

Answer 8

In the real world applications, django definitely has a strong Unix philosophy.

You want to add a "email users and confirm their email, on registration", add an app: (django-registration)[http://bitbucket.org/ubernostrum/django-registration] and point it to an url pattern. You want to add "Add ability to login via Facebook, twitter", add another application: Django-Socialauth and point it onto another url path.

Even the applications themselves, "Do one thing, and do it well" Very unix like.