The Unix Philosophy - Explained and Extended

Introduction

This article explains the principles on which Unix is based in more detail, gives additional examples and clarifications, and ends with an extended description of the Unix philosophy.

Unix and its most popular branches, BSD and GNU/Linux, run on everything and everywhere – on all top 500 supercomputers (GNU/Linux), all Intel CPUs after 2015 (MINIX), all mobile phones and tablets (Android, iOS, and GNU/Linux), all architectures (PC, POWER, ARM, RISC-V, …), and basically everything else related to high-tech research and development. GNU/Linux even runs on 4.5% of all desktops.

As mentioned in the History of Unix, BSD, GNU, and Linux, Unix was originally created in the early 1970s by AT&T Bell Labs’ employees Ken Thompson and Dennis Ritchie, with support from Rudd Canaday, Brian Kernighan, Joe Ossanna, Robert Morris, the department head Doug McIlroy, and few others.

Prior to inventing Unix, its authors were familiar with the earlier operating systems Compatible Time-Sharing System (CTSS), Berkeley Timesharing System, Multics, Incompatible Timesharing System (ITS), and TENEX, all of which contributed novel ideas to the field of operating systems.

After work on Multics, Thompson and Ritchie were in agreement that operating systems of the time were too complex and ran on expensive hardware. They wanted a simpler, interactive, self-contained operating system with a comfortable programming environment, around which a user community could form.

They channeled their past experience, skill, and insight into Unix, and it became clear they had exceptional talent for simple, straightforward expression of ideas. Many features became natural consequences of the underlying design, rather than bulking of code. Unix provided a combination of convenience, simplicity, and power unmatched by any other system.

Already in the 1973 paper The UNIX Time-Sharing System, Ritchie and Thompson stated: “[Unix] offers a number of features seldom found even in larger operating systems”. Thompson stated “[Unix] felt like a mainframe OS on a minicomputer”. Doug McIlroy later said “Unix was an improvement on its predecessors and most of its successors”.

Or as a Bell Labs video about Unix from 1982 described it, “We have 20,000 computer terminals, roughly one per employee. And most of them are used for communicating with Unix systems. One of the main reasons why Unix is popular around here is because it provides graceful facilities for decomposing complex computing tasks into simple subtasks.”

Over time the design principles of Unix were documented and became known as the Unix philosophy.

Unix’ Appearance in the Context of Time

When Unix appeared in the ’70s, it revolutionized the industry in multiple ways. Starting with the characteristics that weren’t as much technical as they were circumstantial, in the context of time, we could mention:

• Quoting Ken Thompson, “It meant the beginning of an end of large computer centers where bureaucracy behind multi-million-dollar machines controlled computing”. Unlike for the expensive mainframes, Unix was intended for, comparatively, more affordable and practical minicomputers and, later, workstations

• It was multi-platform. Before Unix, computer manufacturers typically provided their own operating system bundled with the hardware and there was no any compatibility between manufacturers; sometimes not even between offerings from the same manufacturer. Now users could obtain any computer and install or port Unix to it

• It was small and understandable. The source code was in directory /usr/src/ and could be read line by line, modified, recompiled, and reinstalled, giving users total control over the whole system

• And it was a “big league” operating system with source code available to universities for a nominal fee, making operating systems design courses practical and generating long-lasting interest, enthusiasm, and hacker culture, which later also translated into business demand

Basic Technical Characteristics

Speaking of innovations and going one level closer to technical characteristics, we could say that:

• From the beginning, Unix was designed to be a complete system – it included the kernel, a set of programs to make the system useful, and a set of development tools to make the system self-supported. That meant it came with filesystem utilities, text editors, compilers, debuggers, documentation tools, etc.

• It was designed around modularity, composability, and reuse of basic components, rather than (re)implementation of all features in all programs

• It was user-oriented, encouraging user-level customization of the working environment and community-level formation of user groups. As John Lions of UNSW Australia said, “Unix was an agent of social and technical change within the University.”

• File data was just bytes, without size or structure predefined by the filesystem or the OS (another novel idea at the time). The interpretation of data laid solely with programs that wrote or read them

• Similarly, many other things in the system were regular/non-special programs and behaviors, like the shell (which could be replaced by any other program) and the parsing of command line arguments which was left to individual programs (helped when needed by common library routines)

• The input/output system was also non-assuming and based just around integer-based file descriptors and a standard set of system calls (open, read, write, close). These calls were used for writing to everything – filesystems, devices, and networks

• And the C language, which Dennis Ritchie implemented to abstract Unix source code from the platform-specific assembler instructions, was implemented as a preprocessor which translated C syntax to assembler syntax. As a side-effect, this ensured close relationship between the source code and raw system performance, soon making C the only choice for systems programming in the industry

Unix Philosophy

The previous chapters hopefully shed some light on the history of various characteristics that became part of the Unix philosophy. Over time, Unix’ design principles were explained by its authors and notable users using roughly the following sentences:

• Make it easy to write, test, and run programs.

• Avoid complex interfaces. Simple is beautiful.

• Make each program Do One Thing And Do It Well (DOTADIW). Keep it Simple, Stupid (KISS).

• Prefer economy and elegance of design due to size constraints (“salvation through suffering”).

• Text is a universal interface. Write programs that handle text streams. Store data in flat text files.

• Don’t insist on interactive input. Don’t require long or unnecessary input.

• Don’t output unnecessary information. Avoid columnar or binary output.

• Expect the output of every program to become input to another, unknown program. The power of a system comes more from the relationships between programs than from the programs themselves.

• Build a prototype as soon as possible. Design and build software, even operating systems, to be testable quickly, ideally within weeks. Don’t hesitate to throw away and rebuild clumsy parts.

• Choose portability and developer time over efficiency and machine time.

• Write support tools to help with particular tasks. It doesn’t matter that they are not the main program.

Key Words

Summarizing the above and the Wikipedia page Unix philosophy, the following single words represent Unix well:

• Minimal, simple, compact, clear, readable, lean

• Separate, modular, extensible, composable

• Reusable, repurposable

• Quick, dynamic, agile

Long-lasting Characteristics

With a distance of 50+ years since Unix was invented, we can reflect back in time and round off the article with the following:

1. The design of Unix was general and independent of computing power. Unix commands and concepts that existed in 1970s are still in use today. Learning and practicing Unix means investing in a durable skill that is not too easily changed or made obsolete by commercial companies’ interests.

2. Unix is both powerful and free. That makes it particularly suitable for the extremes of the user spectrum – those that want a free system, and those that want the best system. This characteristic was best described by a saying “Unix makes simple things simple, hard things possible”.

3. Unix authors have properly recognized that text was a universal interface, even though already in the ’70s they had access to advanced technology such as voice synthesis. Similarly to the previous characteristic mentioned, text interestingly caters to the two extremes – the simplest, and the most efficient.

4. Unix is a modular system that facilitates prototyping, experimentation, and reuse. This was best described by a saying “In Unix a program becomes successful when it gets used for a purpose or in combination which the original authors did not anticipate”.

5. Unix’ combination of features and ease with which they are accessed is unparalleled. Development tools or specialized programs are available as readily as other system commands. Such an environment promotes a combination of active and passive users’ expansion of knowledge and skill over time.

6. Thanks to free and open source licenses, BSD and GNU/Linux systems have guaranteed everyone the right to use, study, modify, and share the modified software. The free, unrestricted access to source code and usually its zero cost have removed all artificial barriers to entry and education.