5 Dec
2024
5 Dec
'24
11:53 p.m.
There was no concurrency in mini-Unix; the first pipeline component ran to
completion, and when it exited the next component ran, and so on. In this
way a pipeline could be arbitrarily long using just two disk files.
On Thu, Dec 5, 2024, 12:07 PM Marc Rochkind <mrochkind(a)gmail.com> wrote:
I don't think files as pipes would be
"transparent to the user." Reading
an empty pipe causes a wait until the bytes requested are available, unless
the pipe is closed first. Reading to the end of a file results in an
end-of-file error. This problem is avoided if the source process completes
before the target process begins, but then there is a different lack of
transparency, which is that the processes don't run simultaneously. (I
think this is the case with the implementation that Heinz showed.)
Still, the same sort of pseudo-pipes were in MS-DOS, and they were
occasionally useful.
Marc
On Thu, Dec 5, 2024 at 9:17 AM Heinz Lycklama <heinz(a)osta.com> wrote:
John, thanks for the reminder of the
implementation
of pipes on a constrained version of UNIX in the early
days. The exact implementation is described on page 2095
of the BSTJ July-Aug 1978 for interested parties.
Heinz
On 12/5/2024 8:00 AM, John R Levine wrote:
On Thu, 5 Dec 2024, Dan Cross wrote:
Pipes were invented at least three times I'm aware of, but what made them
work so well in Unix is that they looked to the program the same as a
file
so any program could use them for input or output without special
arrangements,
and the shell made it easy to start two programs and pipe them together.
Once you have coroutines and queues for passing data between them, a
lot of things start to look like pipes.
They also can look a lot like temporary files. Someone, probably Heinz,
did a shell for the tiny Unix that ran on floppies so this
foo | bar
actually did this
foo > tmpfile ; bar < tmpfile; rm tmpfile
to avoid having to swap programs in and out on floppies. The main
disadvantage was that the tmpfile could overflow the tiny disks of the
time.
They were invented again at IBM in the 1970s and described in this
paper. I wrote
them a letter, which they published, saying that Unix pipes did the same
thing.
https://dl.acm.org/doi/10.1147/sj.174.0383
Don't forget CMS pipelines, too!
Sadly, the Morrison paper cited above is not easily accessible, though
If anyone else needs a copy, just ask.
Regards,
John Levine, johnl(a)taugh.com, Taughannock Networks, Trumansburg NY
Please consider the environment before reading this e-mail. https://jl.ly
--
*My new email address is mrochkind(a)gmail.com <mrochkind(a)gmail.com>*
