This is the Unix philosophy: Write programs that do one thing and do it well. Write programs to work together. Write programs to handle text streams, because that is a universal interface.
The UNIX philosophy according to Doug McIlroy, inventor of UNIX pipes
The UNIX philosophy is the classic computer technology example of keeping it simple. It’s the central idea behind the UNIX operating system, which is probably the oldest operating system to still be in regular use (in some form or the other). Conceptually, it’s a wonderful idea: instead of writing programs to do a bunch of different things at some mediocre level, write each program to do one thing well. The input and output to these programs should be in the form of simple text (in the form of flat files, user interactions or input/output for other programs). These programs can them be tied together using pipes and simple shell scripts to achieve a variety of flexible, but complex functionality.
As a regular terminal user, I employ the UNIX philosophy every time I want to quickly search a file or some command’s output without having to see all of it. I use it to makes my life easier by automating lots of tiny little tasks that I do over and over. However, at the same time, I use and love GNU Emacs, which in many ways is the antithesis of the UNIX philosophy. Emacs encourages you to make the editor your home and the Elisp embedded language lets you create all sorts of applications right inside the editor. The classic joke goes that Emacs is really an operating system squeezed into a text editor.
Leaving behind the power user for a moment, much of software seems directly opposed to the UNIX philosophy. A word processor lets you edit text, format it, view it, create simple graphics, insert footnotes, endnotes, bibliographies and print to either electronic or paper formats. With the explosion of the web and especially social networks, things have become even more complicated. Facebook is a giant combination of email, IM, bulletin board, forum, image gallery and general purpose application platform. Considering that Facebook is immensely more popular than the UNIX command line, I have to wonder, is there something about the UNIX philosophy that makes it unattractive to the common user?
As is the case with most similar questions, the answer is both yes and no. One of the ideals behind the UNIX philosophy is uniformity: having one standardized way to do or present something is much better than having dozens of different ad hoc methods. Look closely enough and you’ll see that a lot of popular software adheres to this rule. People like Apple and OS X because everything is neatly tied together. Office suites are useful because they make it easy to share data from one application to the other without having to worry about compatibility and such. Facebook approaches this in a different way: the interface, especially the mini-feed, gives you all the information you need without having to look for it. In both cases, it’s a question of reducing the users mental overhead in accomplishing a specific task.
Even if the UNIX philosophy and good modern software might share same core characteristics, there is still a lot that sets them apart. In particular, the UNIX philosophy is meant to expose power and responsibility to the user. Need to rename dozens of files according to some pattern? There’s a UNIX utility to look up files in a directory, there’s one to rename a file and there are ones to recognize patterns. It’s up to you as a user with at least a passable understanding of shell scripting to whip up something that will get the job done (in less time than it would take to do manually). The people who feel most at home doing things like thing would even go a bit out of their way to learn scripting, if they knew it would save time in the long run. However, this isn’t how most users work. For better or for worse, most users would rather do one of two things: either manually rename the files (something they’re comfortable with) or look for some third party utility which does what they want. While old school tools require some active learning on the users’ part, modern software works hard to lower the bar: it’s dead easy to copy a graph from Excel to Word.
Perhaps part of the problem is that ‘common man’ is an extremely vague term, especially when applied to computer users. There are people who tinker for the sake of tinkering, those who tinker to get the job done, those who simply want to get things over with, those who couldn’t care less, those who would rather be using pen and paper, the list could go and on. Drawing an arbitrary line between power users and everyone else is a gross oversimplification (the number of holy wars even in the power user camp should make that clear). However there are some lessons that can be learned particularly with regard to good software. Good software offers few surprises and lowers the mental overhead needed to get the job done. Something that has a clear, consistent interface is always better than something that is complicated and convoluted. There is also a delicate balance between exposing functionality and confusing the user. Good users provide just enough functionality upfront but makes it easy to get to more advanced features. The command line achieves this by requiring the user to have read the manual to some extent before getting started. Good GUIs strike this balance well, but it’s very easy to mess it up completely.
While this article might have seemed somewhat esoteric, I think it’s important to keep these lessons in mind whenever you’re writing software to be used by a human audience. Crafting good interfaces and choosing the right features for a software product isn’t easy, especially for beginners, but it is something that can be learned mainly by keeping open eyes and an open mind. Happy Hacking.