Berengal wrote: the bondage and discipline inspires rigor.
I find the opposite is true. At least languages with wimpy type systems like C and Java seem to be more of a crutch.
I started with static, went to dynamic, and when I came back, I found I no longer needed static typing. I no longer made type errors with any regularity.
Really, I think Dynamic (+strong) typing is the real BDSM system. It forces you to keep all the types in your head, and punishes you severely for failure to do so. Static says "That's fine. Here's where you made your mistake, hon. Hold my hand next time, OK?" and then gives you a lollipop.
Not only that, but static typing allows IDEs to coddle you in some pretty ridiculous ways. Have you ever used C# with VS2010? Yeesh. (not to say this is a downside. It's awesome, but it IS coddling.)
And the "discipline" is hardly that. By some lang's point of view, the only invariants you could ever want to assert on a number is if its floating point or int or if it's signed or unsigned. What if you have a function that doesn't make sense except on arguments that, when floored, are odd, and are greater than 2*PI? At some level, you have to give up on proving your program correct and do a run-time assert. If you want to get anything done. And I think we can all agree that a language like Python and a language like Java don't actually draw the line too far from one another when you consider the real problem is proving your entire program won't crash before running it.
And, in practice, do programs written in static languages crash less, statistically? I can believe it of something like Ada or Haskell, but not C++.