During the past few years, the Unix operating system has come into wide use, so wide that its very name has become a trademark of Bell Laboratories. Its important characteristics have become known to many people. It has suffered much rewriting and tinkering since the first publication describing it in 1974 [1], but few fundamental changes. However, Unix was born in 1969 not 1974, and the account of its development makes a little-known and perhaps instructive story. This paper presents a technical and social history of the evolution of the system.
For computer science at Bell Laboratories, the period 1968-1969 was somewhat unsettled. The main reason for this was the slow, though clearly inevitable, withdrawal of the Labs from the Multics project. To the Labs computing community as a whole, the problem was the increasing obviousness of the failure of Multics to deliver promptly any sort of usable system, let alone the panacea envisioned earlier. For much of this time, the Murray Hill Computer Center was also running a costly GE 645 machine that inadequately simulated the GE 635. Another shake-up that occurred during this period was the organizational separation of computing services and computing research.
From the point of view of the group that was to be most involved in the beginnings of Unix (K. Thompson, Ritchie, M. D. McIlroy, J. F. Ossanna), the decline and fall of Multics had a directly felt effect. We were among the last Bell Laboratories holdouts actually working on Multics, so we still felt some sort of stake in its success. More important, the convenient interactive computing service that Multics had promised to the entire community was in fact available to our limited group, at first under the CTSS system used to develop Multics, and later under Multics itself. Even though Multics could not then support many users, it could support us, albeit at exorbitant cost. We didn't want to lose the pleasant niche we occupied, because no similar ones were available; even the time-sharing service that would later be offered under GE's operating system did not exist. What we wanted to preserve was not just a good environment in which to do programming, but a system around which a fellowship could form. We knew from experience that the essence of communal computing, as supplied by remote-access, time-shared machines, is not just to type programs into a terminal instead of a keypunch, but to encourage close communication.
Thus, during 1969, we began trying to find an alternative to Multics. The search took several forms. Throughout 1969 we (mainly Ossanna, Thompson, Ritchie) lobbied intensively for the purchase of a medium-scale machine for which we promised to write an operating system; the machines we suggested were the DEC PDP-10 and the SDS (later Xerox) Sigma 7. The effort was frustrating, because our proposals were never clearly and finally turned down, but yet were certainly never accepted. Several times it seemed we were very near success. The final blow to this effort came when we presented an exquisitely complicated proposal, designed to minimize financial outlay, that involved some outright purchase, some third-party lease, and a plan to turn in a DEC KA-10 processor on the soon-to-be-announced and more capable KI-10. The proposal was rejected, and rumor soon had it that W. O. Baker (then vice-president of Research) had reacted to it with the comment `Bell Laboratories just doesn't do business this way!'
Actually, it is perfectly obvious in retrospect (and should have been at the time) that we were asking the Labs to spend too much money on too few people with too vague a plan. Moreover, I am quite sure that at that time operating systems were not, for our management, an attractive area in which to support work. They were in the process of extricating themselves not only from an operating system development effort that had failed, but from running the local Computation Center. Thus it may have seemed that buying a machine such as we suggested might lead on the one hand to yet another Multics, or on the other, if we produced something useful, to yet another Comp Center for them to be responsible for.
Besides the financial agitations that took place in 1969, there was technical work also. Thompson, R. H. Canaday, and Ritchie developed, on blackboards and scribbled notes, the basic design of a file system that was later to become the heart of Unix. Most of the design was Thompson's, as was the impulse to think about file systems at all, but I believe I contributed the idea of device files. Thompson's itch for creation of an operating system took several forms during this period; he also wrote (on Multics) a fairly detailed simulation of the performance of the proposed file system design and of paging behavior of programs. In addition, he started work on a new operating system for the GE-645, going as far as writing an assembler for the machine and a rudimentary operating system kernel whose greatest achievement, so far as I remember, was to type a greeting message. The complexity of the machine was such that a mere message was already a fairly notable accomplishment, but when it became clear that the lifetime of the 645 at the Labs was measured in months, the work was dropped.
Also during 1969, Thompson developed the game of `Space Travel.' First written on Multics, then transliterated into Fortran for GECOS (the operating system for the GE, later Honeywell, 635), it was nothing less than a simulation of the movement of the major bodies of the Solar System, with the player guiding a ship here and there, observing the scenery, and attempting to land on the various planets and moons. The GECOS version was unsatisfactory in two important respects: first, the display of the state of the game was jerky and hard to control because one had to type commands at it, and second, a game cost about $75 for CPU time on the big computer. It did not take long, therefore, for Thompson to find a little-used PDP-7 computer with an excellent display processor; the whole system was used as a Graphic-II terminal. He and I rewrote Space Travel to run on this machine. The undertaking was more ambitious than it might seem; because we disdained all existing software, we had to write a floating-point arithmetic package, the pointwise specification of the graphic characters for the display, and a debugging subsystem that continuously displayed the contents of typed-in locations in a corner of the screen. All this was written in assembly language for a cross-assembler that ran under GECOS and produced paper tapes to be carried to the PDP-7.
Space Travel, though it made a very attractive game, served mainly as an introduction to the clumsy technology of preparing programs for the PDP-7. Soon Thompson began implementing the paper file system (perhaps `chalk file system' would be more accurate) that had been designed earlier. A file system without a way to exercise it is a sterile proposition, so he proceeded to flesh it out with the other requirements for a working operating system, in particular the notion of processes. Then came a small set of user-level utilities: the means to copy, print, delete, and edit files, and of course a simple command interpreter (shell). Up to this time all the programs were written using GECOS and files were transferred to the PDP-7 on paper tape; but once an assembler was completed the system was able to support itself. Although it was not until well into 1970 that Brian Kernighan suggested the name `Unix,' in a somewhat treacherous pun on `Multics,' the operating system we know today was born.
Structurally, the file system of PDP-7 Unix was nearly identical to today's. It had
The important file system calls were also present from the start. Read, write, open, creat (sic), close: with one very important exception, discussed below, they were similar to what one finds now. A minor difference was that the unit of I/O was the word, not the byte, because the PDP-7 was a word-addressed machine. In practice this meant merely that all programs dealing with character streams ignored null characters, because null was used to pad a file to an even number of characters. Another minor, occasionally annoying difference was the lack of erase and kill processing for terminals. Terminals, in effect, were always in raw mode. Only a few programs (notably the shell and the editor) bothered to implement erase-kill processing.
In spite of its considerable similarity to the current file system, the PDP-7 file system was in one way remarkably different: there were no path names, and each file-name argument to the system was a simple name (without `/') taken relative to the current directory. Links, in the usual Unix sense, did exist. Together with an elaborate set of conventions, they were the principal means by which the lack of path names became acceptable.
The link call took the form
link(dir, file, newname)
So that every user did not need to maintain a link to all directories of interest, there existed a directory called dd that contained entries for the directory of each user. Thus, to make a link to file x in directory ken, I might do
ln dd ken ken ln ken x x rm ken
The dd convention made the chdir command relatively convenient. It took multiple arguments, and switched the current directory to each named directory in turn. Thus
chdir dd ken
The most serious inconvenience of the implementation of the file system, aside from the lack of path names, was the difficulty of changing its configuration; as mentioned, directories and special files were both made only when the disk was recreated. Installation of a new device was very painful, because the code for devices was spread widely throughout the system; for example there were several loops that visited each device in turn. Not surprisingly, there was no notion of mounting a removable disk pack, because the machine had only a single fixed-head disk.
The operating system code that implemented this file system was a drastically simplified version of the present scheme. One important simplification followed from the fact that the system was not multi-programmed; only one program was in memory at a time, and control was passed between processes only when an explicit swap took place. So, for example, there was an iget routine that made a named i-node available, but it left the i-node in a constant, static location rather than returning a pointer into a large table of active i-nodes. A precursor of the current buffering mechanism was present (with about 4 buffers) but there was essentially no overlap of disk I/O with computation. This was avoided not merely for simplicity. The disk attached to the PDP-7 was fast for its time; it transferred one 18-bit word every 2 microseconds. On the other hand, the PDP-7 itself had a memory cycle time of 1 microsecond, and most instructions took 2 cycles (one for the instruction itself, one for the operand). However, indirectly addressed instructions required 3 cycles, and indirection was quite common, because the machine had no index registers. Finally, the DMA controller was unable to access memory during an instruction. The upshot was that the disk would incur overrun errors if any indirectly-addressed instructions were executed while it was transferring. Thus control could not be returned to the user, nor in fact could general system code be executed, with the disk running. The interrupt routines for the clock and terminals, which needed to be runnable at all times, had to be coded in very strange fashion to avoid indirection.
By `process control,' I mean the mechanisms by which processes are created and used; today the system calls fork, exec, wait, and exit implement these mechanisms. Unlike the file system, which existed in nearly its present form from the earliest days, the process control scheme underwent considerable mutation after PDP-7 Unix was already in use. (The introduction of path names in the PDP-11 system was certainly a considerable notational advance, but not a change in fundamental structure.)
Today, the way in which commands are executed by the shell can be summarized as follows:
Processes (independently executing entities) existed very early in PDP-7 Unix. There were in fact precisely two of them, one for each of the two terminals attached to the machine. There was no fork, wait, or exec. There was an exit, but its meaning was rather different, as will be seen. The main loop of the shell went as follows.
The most interesting thing about this primitive implementation is the degree to which it anticipated themes developed more fully later. True, it could support neither background processes nor shell command files (let alone pipes and filters); but IO redirection (via `<' and `>') was soon there; it is discussed below. The implementation of redirection was quite straightforward; in step 3) above the shell just replaced its standard input or output with the appropriate file. Crucial to subsequent development was the implementation of the shell as a user-level program stored in a file, rather than a part of the operating system.
The structure of this process control scheme, with one process per terminal, is similar to that of many interactive systems, for example CTSS, Multics, Honeywell TSS, and IBM TSS and TSO. In general such systems require special mechanisms to implement useful facilities such as detached computations and command files; Unix at that stage didn't bother to supply the special mechanisms. It also exhibited some irritating, idiosyncratic problems. For example, a newly recreated shell had to close all its open files both to get rid of any open files left by the command just executed and to rescind previous IO redirection. Then it had to reopen the special file corresponding to its terminal, in order to read a new command line. There was no /dev directory (because no path names); moreover, the shell could retain no memory across commands, because it was reexecuted afresh after each command. Thus a further file system convention was required: each directory had to contain an entry tty for a special file that referred to the terminal of the process that opened it. If by accident one changed into some directory that lacked this entry, the shell would loop hopelessly; about the only remedy was to reboot. (Sometimes the missing link could be made from the other terminal.)
Process control in its modern form was designed and implemented within a couple of days. It is astonishing how easily it fitted into the existing system; at the same time it is easy to see how some of the slightly unusual features of the design are present precisely because they represented small, easily-coded changes to what existed. A good example is the separation of the fork and exec functions. The most common model for the creation of new processes involves specifying a program for the process to execute; in Unix, a forked process continues to run the same program as its parent until it performs an explicit exec. The separation of the functions is certainly not unique to Unix, and in fact it was present in the Berkeley time-sharing system [2], which was well-known to Thompson. Still, it seems reasonable to suppose that it exists in Unix mainly because of the ease with which fork could be implemented without changing much else. The system already handled multiple (i.e. two) processes; there was a process table, and the processes were swapped between main memory and the disk. The initial implementation of fork required only
In fact, the PDP-7's fork call required precisely 27 lines of assembly code. Of course, other changes in the operating system and user programs were required, and some of them were rather interesting and unexpected. But a combined fork-exec would have been considerably more complicated, if only because exec as such did not exist; its function was already performed, using explicit IO, by the shell.
The exit system call, which previously read in a new copy of the shell (actually a sort of automatic exec but without arguments), simplified considerably; in the new version a process only had to clean out its process table entry, and give up control.
Curiously, the primitives that became wait were considerably more general than the present scheme. A pair of primitives sent one-word messages between named processes:
smes(pid, message) (pid, message) = rmes()
The message facility was used as follows: the parent shell, after creating a process to execute a command, sent a message to the new process by smes; when the command terminated (assuming it did not try to read any messages) the shell's blocked smes call returned an error indication that the target process did not exist. Thus the shell's smes became, in effect, the equivalent of wait.
A different protocol, which took advantage of more of the generality offered by messages, was used between the initialization program and the shells for each terminal. The initialization process, whose ID was understood to be 1, created a shell for each of the terminals, and then issued rmes; each shell, when it read the end of its input file, used smes to send a conventional `I am terminating' message to the initialization process, which recreated a new shell process for that terminal.
I can recall no other use of messages. This explains why the facility was replaced by the wait call of the present system, which is less general, but more directly applicable to the desired purpose. Possibly relevant also is the evident bug in the mechanism: if a command process attempted to use messages to communicate with other processes, it would disrupt the shell's synchronization. The shell depended on sending a message that was never received; if a command executed rmes, it would receive the shell's phony message, and cause the shell to read another input line just as if the command had terminated. If a need for general messages had manifested itself, the bug would have been repaired.
At any rate, the new process control scheme instantly rendered some very valuable features trivial to implement; for example detached processes (with `&') and recursive use of the shell as a command. Most systems have to supply some sort of special `batch job submission' facility and a special command interpreter for files distinct from the one used interactively.
Although the multiple-process idea slipped in very easily indeed, there were some aftereffects that weren't anticipated. The most memorable of these became evident soon after the new system came up and apparently worked. In the midst of our jubilation, it was discovered that the chdir (change current directory) command had stopped working. There was much reading of code and anxious introspection about how the addition of fork could have broken the chdir call. Finally the truth dawned: in the old system chdir was an ordinary command; it adjusted the current directory of the (unique) process attached to the terminal. Under the new system, the chdir command correctly changed the current directory of the process created to execute it, but this process promptly terminated and had no effect whatsoever on its parent shell! It was necessary to make chdir a special command, executed internally within the shell. It turns out that several command-like functions have the same property, for example login.
Another mismatch between the system as it had been and the new process control scheme took longer to become evident. Originally, the read/write pointer associated with each open file was stored within the process that opened the file. (This pointer indicates where in the file the next read or write will take place.) The problem with this organization became evident only when we tried to use command files. Suppose a simple command file contains
ls who
sh comfile >output
Solution of this problem required creation of a new system table to contain the IO pointers of open files independently of the process in which they were opened.
The very convenient notation for IO redirection,
using the `>' and `<' characters,
was not present from the very beginning of the PDP-7 Unix system,
but it did appear quite early.
Like much else in Unix,
it was inspired by an idea from Multics.
Multics has a rather general IO redirection mechanism [3]
embodying named IO streams
that can be dynamically redirected
to various devices, files, and even through special
stream-processing modules.
Even in the version of Multics we were familiar with a decade ago,
there existed a command that switched subsequent output
normally destined for the terminal to a file, and another command
to reattach output to the terminal.
Where under Unix one might say
`>'
および
`<'
を用いた入出力リダイレクションを指定する便利な記法は、
PDP-7 Unix に最初から存在していたわけではないが、
すぐにサポートされた。
Unix の他の部分と同様、
これも Multics より受け継がれた概念である。
Multics は、
名前つき入出力ストリームを用いた、
かなり一般性のある入出力切替え機構を備え、
様々なデバイスやファイル、
それに特殊なストリーム処理モジュールに対しても
動的に切替えを行なうことができた。
我々が慣れ親しんだ Multics の10年前のバージョンには、
通常、端末に向いている出力をファイルに切替えたり、
逆に端末に戻したりするためのコマンドが存在した。
Unix 上では次のように指定することで
ls >xx
iocall attach user_output file xx list iocall attach user_output syn user_i/o
By the beginning of 1970, PDP-7 Unix was a going concern. Primitive by today's standards, it was still capable of providing a more congenial programming environment than its alternatives. Nevertheless, it was clear that the PDP-7, a machine we didn't even own, was already obsolete, and its successors in the same line offered little of interest. In early 1970 we proposed acquisition of a PDP-11, which had just been introduced by Digital. In some sense, this proposal was merely the latest in the series of attempts that had been made throughout the preceding year. It differed in two important ways. First, the amount of money (about $65,000) was an order of magnitude less than what we had previously asked; second, the charter sought was not merely to write some (unspecified) operating system, but instead to create a system specifically designed for editing and formatting text, what might today be called a `word-processing system.' The impetus for the proposal came mainly from J. F. Ossanna, who was then and until the end of his life interested in text processing. If our early proposals were too vague, this one was perhaps too specific; at first it too met with disfavor. Before long, however, funds were obtained through the efforts of L. E. McMahon and an order for a PDP-11 was placed in May.
The processor arrived at the end of the summer, but the PDP-11 was so new a product that no disk was available until December. In the meantime, a rudimentary, core-only version of Unix was written using a cross-assembler on the PDP-7. Most of the time, the machine sat in a corner, enumerating all the closed Knight's tours on a 6×8 chess boarda three-month job.
Once the disk arrived,
the system was quickly completed.
In internal structure,
the first version of Unix for the PDP-11 represented a relatively
minor advance over the PDP-7 system;
writing it was largely a matter of transliteration.
For example,
there was no multi-programming; only one user program
was present in core at any moment.
On the other hand,
there were important changes in the interface to the user:
the present directory structure,
with full path names,
was in place,
along with the modern form of
exec
and
wait,
and conveniences like
character-erase and line-kill
processing for terminals.
Perhaps the most interesting thing about the
enterprise was its small size:
there were 24K bytes of core memory
(16K for the system, 8K for user programs),
and a disk with 1K blocks (512K bytes).
Files were limited to 64K bytes.
ディスクが搬入されると、
システムはすぐにでき上がった。
内部構造に関しては、
PDP-11 Unix の最初のバージョンは
PDP-7 のシステムとあまり変わりがなく、
主に書き換えを行なっただけのものであった。
例えば、マルチプログラミング機能がなく、
コア上には常に１つのユーザ・プログラムしか存在し得なかった。
これに対して、ユーザ・インターフェースについてはいくつかの重要な変更があった。
例えば、現在のディレクトリ構造と完全なパス名が取り入れられ、
また現在の形式の
exec
と
wait,
、および端末用の文字消去や行消去のような便利な機能が導入された。
そして、恐らく最も興味を引くと思われるのは、
こうした試みが 24KByte のコア・メモリ (システム用 16Kbyte、ユーザ用 8KByte) と
1KBlock (512KByte) のディスクという小さなシステムで
行なわれたということであろう。
ファイルの大きさは 64KByte に制限されていた。
At the time of the placement of the order for the PDP-11,
it had seemed natural, or perhaps expedient,
to promise a system dedicated to word processing.
During the protracted arrival of the hardware,
the increasing usefulness of PDP-7 Unix
made it appropriate to justify creating PDP-11 Unix
as a development tool,
to be used in writing the more special-purpose system.
By the spring of 1971,
it was generally agreed that
no one had the slightest interest in scrapping Unix.
Therefore,
we transliterated the
roff
text formatter
into PDP-11 assembler language,
starting from the PDP-7 version that
had been transliterated
from McIlroy's BCPL version on Multics,
which had in turn been inspired
by J. Saltzer's
runoff
program on CTSS.
In early summer,
editor and formatter in hand,
we felt prepared to fulfill our charter by offering
to supply a text-processing service to the
Patent department for preparing patent applications.
At the time,
they were evaluating a commercial system for this purpose;
the main advantages we offered
(besides the dubious one of taking part in
an in-house experiment)
were two in number:
first,
we supported Teletype's model 37 terminals,
which, with an extended type-box,
could print most of the math symbols they required;
second, we quickly endowed
roff
with the ability to produce line-numbered pages,
which the Patent Office required and which the other
system could not handle.
PDP-11 を発注する時点では、
システムを専ら文書処理に用いる事にした方が自然で、
しかも都合が良かった。
しかしながら、ハードウェアの搬入が遅れている間に
PDP-7 Unix
の有用性はますます高まり、
特殊目的のシステムを作成するのに使うことのできる
開発ツールとして、
PDP-11 Unix を作成した方が良いということになった。
1971 年の春には、
Unix を捨てようなどとは誰も考えなくなっていたほどである。
こうして、
我々はまずテキスト・フォーマッタの
roff
を PDP-7 から PDP-11 のアセンブリ言語に移植した。
この
roff
は、
そもそも CTSS 上で稼働していた
J. Saltzer
の
runoff
にヒントを得て作成された、
Multics 上の McIlroy の BCPL バージョンから
PDP-7 に移植されたものである。
夏の始めに、
エディタとテキスト・フォーマッタが利用できるようになり、
我々は購入時の約束を果たすため、
特許部に対し特許申請書作成用に文書処理サービスを提供する事を考えた。
その頃、
特許部ではこの目的のために商用システムの購入を検討していた。
我々の提案には、
(所内の実験に協力するということはさておき)
２つの利点があった。
１つは、
当時、我々が Teletype 社のモデル 37 端末を持っていたという事である。
この端末は拡張された字体をサポートし、
彼らが使用する数学記号のほとんどが印字可能であった。
もう１つは、
我々が
roff
に行番号付きのページ出力機能を付加した事である。
この機能は、特許部で必要としていたが、
当時、これをサポートするシステムは存在しなかった。
During the last half of 1971,
we supported three typists from the Patent department,
who spent the day busily typing, editing, and formatting patent applications,
and meanwhile tried to carry on our own work.
Unix has a reputation for supplying interesting services on modest hardware,
and this period may mark a high point in the benefit/equipment ratio;
on a machine with no memory protection and a single .5 MB disk,
every test of a new program required care and boldness,
because it could easily crash the system,
and every few hours' work by the typists
meant pushing out more information onto DECtape,
because of the very small disk.
1971年の後半は、特許部から３人のタイピストが我々のところに出向して
終日、特許申請書の入力、編集、整形を行ない、
一方で我々は我々自身の仕事を続けた。
現在、Unix は手頃なハードウェアで価値あるサービスが得られる
という点で評判となっているが、当時は、
便利さと設備の比が最高値に達していた時期といえよう。
すなわち、マシンにはメモリ保護機構がなく、
0.5MB のディスク１台しかなかったため、
新たなプログラムをテストするたびに、
最新の注意と勇気を必要とした。
システムは簡単にクラッシュしたし、
またディスクが極めて小さかったため、
タイピスト達が数時間仕事をするたびに、
ディスク中の情報を DECtape に退避しなければならなかったからである。
The experiment was trying but successful.
Not only did the Patent department adopt Unix,
and thus become the first of many groups
at the Laboratories to ratify our work,
but we achieved sufficient credibility
to convince our own management to acquire
one of the first PDP 11/45 systems made.
We have accumulated much hardware since then,
and labored continuously on the software,
but because most of the interesting work has already been published,
(e.g. on the system itself [1, 5, 6, 7, 8, 9])
it seems unnecessary to repeat it here.
実験は何とか成功にこぎ着けることができた。
特許部は Unix を採用し、
これによって研究所内の多くの部署で我々の仕事が認められるようになった。
それどころか、我々自身の管理者に
最初に作られた PDP-11/45 システムのうちの１台を獲得することを
納得させられるだけの信用を得たのである。
以後、我々はハードウェアの充実を図り、
ソフトウェアの整備を行なってきたが、
これらの興味深い仕事のほとんどは既に公表されているので
(システム自身 [1, 5, 6, 7, 8, 9]) 、
ここでそれを繰り返す必要はないと思われる。
One of the most widely admired contributions of Unix
to the culture of operating systems and command languages
is the
pipe,
as used in a pipeline of commands.
Of course, the fundamental idea was by no means new;
the pipeline is merely a specific form of coroutine.
Even the implementation was not unprecedented,
although we didn't know it at the time;
the `communication files' of the Dartmouth
Time-Sharing System [10]
did very nearly what Unix pipes do,
though they seem not to have been exploited so fully.
Unix のオペレーティング・システム
およびコマンド言語の分野に対する寄与の中で最大級の、
幅広い評価を得ているものの１つに、
コマンドのパイプライン処理を行なうための
pipe
がある。
もちろん、パイプの基本的な考えは決して新しいものではなく、
パイプラインは単に
coroutine
の特殊な形式に過ぎない。
当時、我々は気づいていなかったのだが、
実現された先例さえあった。
それは、
Dartmouth Time-Sharing System [10]
の
`communication files'
で、
その後、十分に発展がなかったようであるが、
すでに Unix の pipe とほぼ同じことを実現していた。
Pipes appeared in Unix in 1972,
well after the PDP-11 version of the system was in operation,
at the suggestion (or perhaps insistence) of M. D. McIlroy,
a long-time advocate of the non-hierarchical control flow
that characterizes coroutines.
Some years before pipes were implemented, he suggested
that commands should be thought of as binary operators,
whose left and right operand specified the input and output files.
Thus a `copy' utility would be commanded by
Unix に pipe が実現されたのは、
PDP-11 上でシステムが稼働しだしてからずっと後の 1972 年のことである。
これは、
coroutine
の特徴である非階層型の制御フローを以前から提唱していた
M. D. McIlroy
の示唆
(というより主張)
によるものである。
pipe が実現される数年前、
彼はコマンドを左右のオペラントが入力および出力ファイルを指定する
２項演算子と考えるべきであることを提案した。
これによると、コピー・ユーティリティは次のようなコマンドで指定される。
inputfile copy outputfile
input sort paginate offprint
sort input | pr | opr
Some time later, thanks to McIlroy's persistence,
pipes were finally installed in the operating system
(a relatively simple job),
and a new notation was introduced.
It used the same characters as for I/O redirection.
For example, the pipeline above might have been written
その後しばらくして
McIlroy
の主張によりパイプがオペレーティング・システムに組み込まれ
(比較的簡単な作業であった)
新しい表記法が導入された。
それは、入出力リダイレクションと同じ文字を使用するものであった。
例えば、上で述べたパイプラインは、次のような形で指定された。
sort input >pr>opr>
The new facility was enthusiastically received, and
the term `filter' was soon coined.
Many commands were changed to make them usable in pipelines.
For example, no one had imagined that anyone would want the
sort
or
pr
utility to sort or print its standard input if given no explicit arguments.
この新しい機能は熱狂的に受け入れられ、
やがて
`filter'
という用語も造り出された。
多数のコマンドがパイプラインで使用できるよう書き換えられた。
例えば、それまで、
sort
や
pr
ユーティリティを引数なしで用いるとき
標準入力からデータを得るなどという発想は誰も持たなかった。
Soon some problems with the notation became evident.
Most annoying was a silly lexical problem:
the string after `>' was delimited by blanks, so,
to give a parameter to
pr
in the example, one had to quote:
しばらくして、この表記法に関していくつかの問題点が明らかになった。
最も厄介だったのは、つまらない構文上の問題であった。
つまり、
`>'
の後の文字列は空白で区切られるため、
例えば上の例で
pr
にパラメータを与えようとすると、
次のように引用符で囲む必要があった。
sort input >"pr -2">opr>
opr <pr<"sort input"<
pr <"sort input"< >opr>
I mentioned above in the section on IO redirection that Multics
provided a mechanism by which IO streams could be directed
through processing modules on the way to (or from) the device
or file serving as source or sink.
Thus it might seem that stream-splicing in Multics
was the direct precursor of Unix pipes, as Multics
IO redirection certainly was for its Unix version.
In fact I do not think this is true, or is true only in a weak sense.
Not only were coroutines well-known already,
but their embodiment as Multics spliceable IO modules
required that the modules be specially coded in such a way
that they could be used for no other purpose.
The genius of the Unix pipeline is precisely that it
is constructed from the very same commands used constantly
in simplex fashion.
The mental leap needed to see this possibility
and to invent the notation is large indeed.
入出力リダイレクションの節で述べたように、
Multics では入出力ストリームを任意のデバイスあるいはファイルへ(から)、
処理モジュールをつないで変更することが可能であった。
従って、この Multics のストリーム続き合わせ機構は、
Unix のパイプの前身と見ることができるかも知れない。
しかし、私としてはそうではない、
あるいはそうであったとしてもそれほどのものではないと考えている。
coroutine
は当時すでに広く知られた概念であり、
また、Multics が続き合わせ可能な入出力モジュールとして実現したものは、
他の用途に使用できないほど特殊なコーディングがなされていたのである。
Unix のパイプラインの思想は、
まさに、しばしば単体で用いられるコマンドを
そのままの形でパイプラインの構成要素として用いるというものである。
パイプラインの実現の可能性を探り、
新しい表記法を案出するには、
実に大きな精神的飛躍が必要であった。
Every program for the original PDP-7 Unix system was written in assembly language, and bare assembly language it wasfor example, there were no macros. Moreover, there was no loader or link-editor, so every program had to be complete in itself. The first interesting language to appear was a version of McClure's TMG [11] that was implemented by McIlroy. Soon after TMG became available, Thompson decided that we could not pretend to offer a real computing service without Fortran, so he sat down to write a Fortran in TMG. As I recall, the intent to handle Fortran lasted about a week. What he produced instead was a definition of and a compiler for the new language B [12]. B was much influenced by the BCPL language [13]; other influences were Thompson's taste for spartan syntax, and the very small space into which the compiler had to fit. The compiler produced simple interpretive code; although it and the programs it produced were rather slow, it made life much more pleasant. Once interfaces to the regular system calls were made available, we began once again to enjoy the benefits of using a reasonable language to write what are usually called `systems programs:' compilers, assemblers, and the like. (Although some might consider the PL/I we used under Multics unreasonable, it was much better than assembly language.) Among other programs, the PDP-7 B cross-compiler for the PDP-11 was written in B, and in the course of time, the B compiler for the PDP-7 itself was transliterated from TMG into B.
When the PDP-11 arrived, B was moved to it almost immediately. In fact, a version of the multi-precision `desk calculator' program dc was one of the earliest programs to run on the PDP-11, well before the disk arrived. However, B did not take over instantly. Only passing thought was given to rewriting the operating system in B rather than assembler, and the same was true of most of the utilities. Even the assembler was rewritten in assembler. This approach was taken mainly because of the slowness of the interpretive code. Of smaller but still real importance was the mismatch of the word-oriented B language with the byte-addressed PDP-11.
Thus, in 1971, work began on what was to become the C language [14]. The story of the language developments from BCPL through B to C is told elsewhere [15], and need not be repeated here. Perhaps the most important watershed occurred during 1973, when the operating system kernel was rewritten in C. It was at this point that the system assumed its modern form; the most far-reaching change was the introduction of multi-programming. There were few externally-visible changes, but the internal structure of the system became much more rational and general. The success of this effort convinced us that C was useful as a nearly universal tool for systems programming, instead of just a toy for simple applications.
Today, the only important Unix program still written in assembler is the assembler itself; virtually all the utility programs are in C, and so are most of the applications programs, although there are sites with many in Fortran, Pascal, and Algol 68 as well. It seems certain that much of the success of Unix follows from the readability, modifiability, and portability of its software that in turn follows from its expression in high-level languages.
One of the comforting things about old memories is their tendency to take on a rosy glow. The programming environment provided by the early versions of Unix seems, when described here, to be extremely harsh and primitive. I am sure that if forced back to the PDP-7 I would find it intolerably limiting and lacking in conveniences. Nevertheless, it did not seem so at the time; the memory fixes on what was good and what lasted, and on the joy of helping to create the improvements that made life better. In ten years, I hope we can look back with the same mixed impression of progress combined with continuity.
I am grateful to S. P. Morgan, K. Thompson, and M. D. McIlroy for providing early documents and digging up recollections.
Because I am most interested in describing the evolution of ideas, this paper attributes ideas and work to individuals only where it seems most important. The reader will not, on the average, go far wrong if he reads each occurrence of `we' with unclear antecedent as `Thompson, with some assistance from me.'