Also, your first three points puts Ruby pretty much out of the picture.
EDIT: Mentioned Ruby because that's what I am working on right now, after Java and Scala
That someone is worried about being sloppy really only lets you assume they don't write code they consider sloppy.
Of course, that will actually mean they move much more slowly due to bug fixes, but a junior dev in an environment without a good senior dev can easily fall to the "quick and dirty" fallacy.
One of the most important things I learned from chess was to go back over your previous games and look for what mistakes you made, why you made them, and how you can avoid them next time.
Do this same analysis with every BUG you see a bug in your code(whether you wrote it or not). Ask yourself why you or someone else make this mistake? What is because they a assumed a method did something it didn't? Was it because the domain logic wasn't in a single easy to find place so they reinvted the wheel and did it incorrectly?
And for 4) - don't be afraid to build instrumentation into the code base to support decisions about correct operation.
1) Use the best language you can get away with. This means using a language that eliminates entire classes of run-time errors via some or all of:
2) Assume that your code will be maintained by somebody who doesn't know your programming language as well as you do.3) Use static and dynamic assertions liberally.
4) Ease debugging. Have great formatted dumps of your internal data structures, great internal consistency checking, and great logging. Automate problem isolation, too: for example, in an optimizing compiler, at each point where a discretionary change is about to be made, call a function that logs the change, increments a counter, and returns false if the counter is past a limit that you can set in the environment; this allows an automated bisection analysis to immediately find the change that broke a test program.
5) Regression tests. Once you fix a bug, make sure that your test suite will notice recrudescence.
6) Don't hire or retain sloppy programmers.