One thing that's perhaps not obvious in a message-passing environment is the need to follow a strict send-hierarchy. What this means is that two threads should never send messages to each other; rather, they should be organized such that each thread occupies a level; all sends go from one level to a higher level, never to the same or lower level. The problem with having two threads send messages to each other is that eventually you'll run into the problem of deadlock; both threads are waiting for each other to reply to their respective messages. Since the tahreads are blocked, they'll never get a chance to run and perform the reply, so you end up with two (or more!) hung threads.
The way to assign the levels to the threads is to put the outermost clients at the highest level, and work down from there. For example, if you have a graphical user interface that relies on some database server, and the database server in turn relies on the filesystem, and the filesystem in turn relies on a block filesystem driver, then you've got a natural hierarchy of different processes. The sends will flow from the outermost client (the graphical user interface) down to the lower servers; the replies will flow in the opposite direction.
While this certainly works in the majority of cases, you will encounter situations where you need to break the send hierarchy. This is never done by simply violating the send hierarchy and sending a message against the flow, but rather by using the MsgDeliverEvent() function, which we'll take a look at later.