I've noticed two methods to "message passing". One I've seen Erlang use and the other is from Stackless Python. From what I understand here's the difference
Erlang Style - Messages are sent and queued into the mailbox of the receiving process. From there they are removed in a FIFO basis. Once the first process sends the message it is free to continue.
Python Style - Process A queues up to send to process B. B is currently performing some other action, so A is frozen until B is ready to receive. Once B opens a read channel, A sends the data, then they both continue.
Now I see the pros of the Erlang method being that you don't have any blocked processes. If B never is able to receive, A can still continue. However I have noticed in some programs I have written, that it is possible for Erlang message boxes to get full of hundreds (or thousands) of messages since the inflow of messages is greater than the outflow.
Now I haven't written a large program in either framework/language so I'm wondering your experiences are with this, and if it's something I should even worry about. 
Yes, I know this is abstract, but I'm also looking for rather abstract answers.
Broadly speaking, this is unbounded queues vs bounded queues.  A stackless channel can be considered a special case of a queue with 0 size.
Bounded queues have a tendency to deadlock.  Two threads/processes trying to send a message to each other, both with a full queue.
Unbounded queues have more subtle failure.  A large mailbox won't meet latency requirements, as you mentioned.  Go far enough and it will eventually overflow; no such thing as infinite memory, so it's really just a bounded queue with a huge limit that aborts the process when full.
Which is best?  That's hard to say.  There's no easy answers here.
blocking channels vs async message passing