Now, about this named pipe. Your writer repeatedly opens the pipe, writes one line of text to it, and closes the pipe. The reader repeatedly opens the pipe, reads one line of text from it, then closes the pipe.

Something you need to realize about pipes is that they don't hold data independent of their writers and readers. You can't open a pipe, write some data, and close the pipe, leaving the data to be read by future reader. They don't work that way.

When a writer opens a pipe, the open() blocks until a reader also opens the pipe. Then, all writes to the pipe are passed directly to the reader. If both reader and writer close the pipe while some data is waiting to be read, that data is lost.

On top of that, the reader is doing buffered reads, which means that it's reading all available data from the pipe, not just one line's worth. The rest of the data is held inside an IO buffer, waiting for you to use <> again. When you close & reopen the pipe instead, you lose the buffered data.

In short, you have a race condition between these two processes. If the writer manages to write two lines to the pipe before the reader reads, then the reader will read both lines at once, return one of them to your script, and throw the other line away when you close the pipe.

To fix your writer, you just need to open the pipe once instead of multiple times. In bourne shell you could do this:

    for word in foo bar baz bletch quux qip qua
    do
        echo $word
    done > foo
[download]

    open FIFO, "<foo" or die "foo: $!\n"; 
    while (<FIFO>) {
      chomp;  
      print "$_\n"; 
    }
[download]