In a shell pipeline of 'a | b | c | d', I can see the dataflow clearly. 'c' never sees the output of 'a' directly; it must be mediated by 'b'. But for a stack, 'a b c d', I have no idea if c uses the value a or not, unless I know the definition of b and how many items c consumes.
When reading stack code, I find myself mentally inserting parentheses to see how far back each operation reaches; for higher-level operators, I find myself wanting to insert comments describing the shape of the code being implicitly constructed. I need to see the "tree" (though frequently a dag) shape.
This isn't different in complex infix expressions. There too, parentheses are often needed for clarity - and good programmers use them even when not necessary - and for very complicated expressions, I'll spread them out across multiple lines, with indentation to make the tree explicit, where performance or similar concerns prevents writing out the expression in a more long-hand fashion.
I've also been doing a lot of Max/MSP programming lately and really love working in its "passing messages along patch cables" system, but am frustrated by its lack of higher order objects and lack of aggregate data types (hell, it won't even let me create a list of lists).
What I really want is a Max/Pd-like language with richer set of data types (algebraic types with pattern matching would be a good start) which can be trivially and unambiguously converted between visual and textual representations. A concatenative language may make this a lot easier.
It's an applicative language created especially for audio DSP. It seems to bridge the gap you describe by providing dataflow combinators and a graphical representation for programs.
Also, Factor does allow you to use local (named) variables and infix syntax when it makes more sense to do so. Concatenative languages do not need to be unreadable at all and for some things I think the concatenative code is actually more naturally readable.
"If c consumes two arguments, in applicative terms it would be d(c(b, a)); if b consumes one argument and c only one, then it would be d(c(b(a))); if d consumes two arguments, b one, and c none, then it would be d(c, b(a))."
'a b c d' in a concatenative language is akin to 'a | b | c | d' in a shell script (where a stack is being threaded from function to function) or 'd(c(b(a(STACK))))' in most languages where each function has a type 'Stack func (Stack s)'. It doesn't change depending on how many arguments a function takes off the stack - its always 'd(c(b(a(STACK))))'. Of course, since literals are essentially functions which push their value onto the stack, what you say is true if a, b and c are literals. I don't find this nearly as confusing as what it sounds like from your comment.
In code like '1 2 + print', all the words you see are functions. 1 pushes the value of 1 onto the stack and so on. This is interesting because you can easily factor out any part by replacing it with a new word that calls the replaced word:
A and B are the exact same.This is also interesting: http://concatenative.org/wiki/view/Concatenative%20language