Irreal

Someone has reposted Thomas Scoville’s article from 1998 on Unix as Literature. The article’s premise is that Unix (and these days, Linux) users are different from the users of other systems. That seems like a low calorie assertion but it’s his claim of how they differ that’s interesting. Unix users, he says, are over-represented by polyglots, people with liberal arts backgrounds, and generally those of an intellectual bent.

For years, Scoville wondered why that was and then he realized that one of the complaints from non-Unix people was that there is too much typing involved in using Unix. Windows people, as one example, don’t do that. They point and click and use menus to get things done. Unix people are more inclined to build pipelines out of obscurely named, tiny applications.

His conclusion is that Unix users are different because they are text oriented, like to read and write and are generally comfortable with wordsmithing. One might say, although he doesn’t, that Unix is the operating system for the literate.

Not even Scoville takes the premise all that seriously but I think it is true that Unix folks like—or at least don’t mind—using the command line, learning a largish collection of utilities, and putting them together in novel ways. It’s also true that others much prefer to have their workflows predefined and callable with a click. No typing required. It’s at least arguable that the first group is more likely to have literate interests. But read the article and decide for yourself.

This post is a blast from the past \(\times 2\). One reason it’s a blast from the past is that it discusses the Unix V6 code. The other reason is that it discusses some of the code that first helped me understand what was going on with Unix.

One of the real wins in Unix is the notion of pipes. Not even Ken Thompson or Dennis Ritchie understood this at first. It was Doug McIlroy, who insisted that the ability to link processes be implemented, who was responsible. One of the things that everyone in the labs say about them is that they were all astounded how quickly the ability lead to a whole new way of thinking about computation. Once pipes were implemented, it was almost trivial to make applications talk to each other and build up the modern notion of pipelines.

The thing about pipes is that despite their power, they have a fairly simple implementation. Abhijit Menon-Sen has an illuminating post that explains how pipes are implemented. If you go through his post, you will see that there’s not that much code in the pipe implementation and that it’s pretty easy to understand. I started with the V7 code base but it’s not much different and after I understood that, most of the other things in the kernel seemed to come easily.

Since the early days, there have been alternative implementations. BSD used Unix domain sockets for a while and later AT&T Unix versions built them on top of the STREAMS mechanism. BSD, at least, found the socket implementation too slow and reverted to the traditional mechanism. Linux, of course, never implemented the STREAMS paradigm so most extant Unices are using the traditional implementation.

If you read and understand the pipe implementation code you will find that you understand many of the important Unix kernel mechanisms and will be able to understand the rest of the kernel fairly easily.