Unix

Unix (officially trademarked as UNIX®) is a computer operating system originally conceived and developed by a group of researchers as an unofficial project while they were working at AT&T's Bell Laboratories. One of the most remarkable aspects of Unix is the fact that due to a consent decree made by the U.S. government, the operating system could not officially be a product developed and sold by AT&T due to its status as a "managed monopoly."

The success and popularity of Unix are the result of several factors, including the openness of its development and the fact it was allowed to be studied at universities by students and professors alike. Unix and its source code was copied and studied at colleges freely, and at the time its development was quite open compared to other commercial operating systems of the time. This contrasts with the development model common in the 1970s, where proprietary software developed by companies was closely guarded, and nothing like the open source movement had taken root.

Unix's implementation has influenced the subsequent design of both the many operating systems that followed it and many University students that have studied it. The desire for more portability in operating systems inspired by Unix also led to the co-development by Dennis Ritchie of the ubiquitous C programming language. Unix was ported from low-level PDP-7 machine language (a computer system popular in the 1960s) to C in order to make it easy to port to different hardware architectures. If a C compiler was created on another hardware platform, compiling Unix on that platform would be easier because Unix would be written in C.

The "open nature" of Unix development had a profound impact on Unix and its descendants, especially in later years when AT&T decided to attempt to take ownership of it. Many developers were scared away by the legal proceedings that AT&T initiated and jumped ship to other operating systems that were unencumbered, most notably the GNU project and Linux. These legal issues have since been resolved, and today there are many popular releases of Unix descendants, most notably Sun Microsystem's Solaris 10 (which was recently made open source) and the BSD variants.

Unix History

Project Origins

It can be said that Unix was born out of the frustration that resulted from the creation of Multics. The Multics project suffered from the well known "second system effect": its predecessor, CTSS (the 'compatible time sharing system') worked quite well, so computer scientists of the era decided to make Multics "even better." The Multics project did integrate many innovations, but ended up collapsing under its own weight because its designers were overly ambitious. This was the setting in which Unix was conceived.

Unix was designed at Bell Laboratories, one of the more unusual workplaces that encouraged research "for the sake of research." Innovations created at Bell Labs would come to define a large part of the future of computer software, as projects that emerged such as Unix and the C programming language became staples of the industry.

Much like the projects that derive from it, development of Unix was started with the influence of another project. Ken Thompson and Dennis Ritchie, the inventors of Unix, worked on the ambitious Multics project until Bell Labs dropped out of the Multics development effort in 1969. Thompson and Ritchie began working on a new system unofficially, and the Unix system's name is a pun on Multics attributed to Brian Kernighan who later went on to co-create the C programming language.

The original group of four who played the biggest parts in the beginnings of Unix were Ken Thompson, Dennis Ritchie, M. D. McIlroy, and J. F. Ossanna

Unix would have faded into obscurity as yet another OS developed from scratch (known as reinventing the wheel), however in 1972 a defining event occurred. Unix was rewritten not in a native assembly language for a specific platform, but in the newly developed C programming language. This made Unix the first "portable operating system." Instead of rewriting the OS from scratch for each newer successive platform, simply the C compiler had to be ported to that architecture. This concept of portability was the "killer app" in the popularity and development of Unix.

see also the "Evolution of the Unix Time-sharing System" article in the External Links section

The Unix Renaissance

Because Unix at first was not an "official project" at Bell Labs, it enjoyed a level of openness not normally enjoyed by commercial software projects. This was felt most at colleges and universities at the time, whose students were studying the innards of the operating system to gain further understanding of the internals and nuances of operating system design and development. This also fostered interest in the project: because students were already familiar with Unix from school, they were more likely to use it later in their professional lives after college. The openness of Unix when it was first developed only served to increase its popularity where it mattered most.

for more information, see the Berkeley Software Distribution article

AT&T Litigation

During the late 1970s and early 1980s, after the academic 'golden age' of Unix the influence it had in the classroom on young academics that were "learning by doing" led to large-scale adoption (particularly of the BSD variant) of Unix by commercial startups, most notably Sun Microsystems. Also AT&T finally decided to sit up and take notice, and this led directly to battle lines in courts being drawn. AT&T was suddenly fighting in court to prove that it "owned Unix."

At the time Unix was developed and was gaining popularity, AT&T was limited by a 1956 consent decree imposed by the United States Department of Justice which forced "Ma Bell" (AT&T) to limit its activities to the regulated business of the national telephone system (the Public Switched Telephone Network or PSTN). Therefore, Unix could not be sold commercially. The breakup of AT&T and its release from that decree in the mid 1980s would have a profound impact on Unix' history, as AT&T was then allowed to develop and sell Unix commercially, and the company decided to pursue what it saw as Intellectual Property that it owned.

Today

Today, in addition to certified Unix systems (see POSIX for the "official" Unix certification standard), Unix-like operating systems such as Linux, Mac OS X and BSD derivatives have matured and flourished, and many derivative works owe their ancestry to Unix roots.

In addition, operating systems developed from scratch can still be officially certified "UNIX," as the new Mac OS X 10.5 "Leopard" is. This helps ensure backwards compatibility because source code can be easily recompiled to run on a "certified system." In the Linux world, a similar effort is being made with the Linux Standards Base.

Common Unix Similarities

Among the diverse array of different variations of Unix, there are general similarities that one can expect to see consistently among the different versions. Listed here are several of the "common traits" of Unix in general.

The philosophy of Unix

Although there is quite a variety among Unix systems, one common theme is the so-called "small tools that do their job very well." That is, a Unix system has many programs, each of which specializes in a small task. The user can combine these tools (via scripting or piping) to accomplish higher level goals. Although this may make some tasks more difficult than common graphical user interfaces, it allows the user to perform complicated tasks that were not explicitly allowed for by the interface's designer.

For instance, suppose the user wanted to create an archive of all files which reference his vacation created between two and three month ago. Under Unix, this could be accomplished as a combination of tar (the archiving application), find (a file search application) and grep (a file pattern matching application). In a single command:

tar czf vacation.tar.gz `find . -ctime +60 -ctime -90 -exec grep -il vacation {} \;`

In contrast, a user in a typical graphical user interface would need to use the search application to find such files, wait for the search to complete, and then use an archiving application to create the archive.

The 'pipe' command takes the return from one command and hands it over to another.

ps aux | grep "firefox"

will run the 'ps' command and run the response through the 'grep' command looking for any line which matches the search "firefox".

Everything is a file

In Unix everything system related is represented as a file. Special "character device files" are used to represent everything from memory, to attached devices such as mice and keyboards, to the "bit bucket". Even random data needed for encryption can be pulled from /dev/random or /dev/urandom (files whose purpose is simply to output random data). Also statistics on the system are represented in a special virtual file system called /proc.
For example, showing the contents (using the 'cat' command) of /dev/mouse would generate input on the screen as you moved the mouse, and specifics of the processor in use can be found in the file /proc/cpuinfo.
This design philosophy was taken to another level by another operating system implemented by Unix's designers, Plan 9. In Plan 9, every machine on the network is represented by files, and are remotely accessible.

File Structure

One of the more influential aspects of UNIX and UNIX-like systems is their hierarchical file structure. Files are organized into directories, each of which contains further directories and files in a branching structure, with the slash character "/" used to mark directory nodes. Each directory and file in UNIX also possesses a permissions string, with nine switches which can be set to allow (r)ead, (w)rite, and e(x)ecute permissions for (u)ser, (g)roup, and (others). A list (ls -l) command might, for example, return the string

drwxr-xr-x     6 jsmith  jsmith   204 Nov  4 11:12 directoryname

which indicates that the node is a directory, flagged for read, write and execute permission for its user, and read and execute only for its user's group, and others.

This combination of hierarchical structure and permissions settings enables a flexible permissions structure, that has also been included in the POSIX family of Unix standards.

User groups can be set to allow different access levels across one branch, or the entire tree, with minimal difficulty. The superuser known as "root" in UNIX automatically has access to all files and directories.

The integration of Access Control Lists, which represent an evolution in file system permissions and allows more granular permissions control, was first implemented in Sun's Solaris operating system. Projects are also currently underway on several Unix variations, such as Linux and FreeBSD.

POSIX

POSIX is a standard Application Programming Interface (or API) defined by the IEEE. POSIX is usually thought of as a "Unix benchmark" today. Products that aim for Unix compliance can gain POSIX certification if they meet the requirements of the POSIX standard.

Culture of Unix

As many of the best programmers and engineers have worked on Unix and the software running on it, much of the operating system contains a distinct flavor or culture reflecting those who use and have helped build Unix - both inside AT&T, inside commercial vendors, in universities and research departments and now on the Internet and through open source software. It has also transcended paradigms: running on everything from 1960s-era mainframe computers, timesharing systems, mini-computers, micro-computers, personal computers, notebooks and even embedded devices like cellphones, set-top boxes and routers. Eric S. Raymond's The Art of Unix Programming lists the following as being the basics of Unix philosophy (drawing from the writings of Doug McIlroy, Rob Pike, Ken Thompson):

• 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 with 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: "Repair what you can — but 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."

Unix Today

Today Unix has a diverse and varied background, and various systems are split into branches of development, modified over time by AT&T as well as various commercial vendors and non-profit organizations (some of them drawing enough influence and inspiration from Unix that they are referred to as being Unix-like).

Here is a quick list of maintained modern operating systems that either have a Unix heritage or are certified Unix (in alphabetical order):

• The BSDs: FreeBSD / OpenBSD / NetBSD / Dragonfly BSD
• Linux
• Mac OS X

Copyright Owner

The present owner of the trademark UNIX® is The Open Group, an industry standards consortium. Only systems fully compliant with and certified to the Single UNIX Specification (SUS) qualify as "UNIX®" (others are called "Unix system-like" or "Unix-like"). Similarly, POSIX defines a standard set of system calls, utilities and standard library functions for Unix-like systems.