I tend to use signed types as much as possible, and use unsigned types only where it is really neccessary or natural (like bitflags).
What I dislike is misuse of unsigned types, so I try to distinguish two types of unsigned values:
a) values which are not really numbers - like bitflags
b) values which domain is [0, oo) - like screen coordinates
As of a), unsigned types are more practical because of right shift and some other operations.
As of b), I often see (mis)use of unsigned types (even STL does it!) where signed type are perfectly natural and easier to use. Having a value which domain is [0, oo) doesn't imply its type should be unsigned, because domain for most of variables is usually [0, N], so values [N+1, oo) are still invalid for that domain.
Of-by-one values (like, -1 and 4294967295) are invalid and should both be check for correctness. Having type of some variable declared as signed doesn't imply its value will be correctly positive during runtime - you still have to assert/check it not only for -1/4294967295, but also for true valid range of that values. Having that in mind, I prefer to have functions like:
bool is_valid_value(<some-type> value)
So, my vote is for use of s32 as much as possible.
EDIT: ... meaning, +1 for CuteAlien's #4