At the other end of the scale are
functional languages with a strong
type system like
Haskell. At my
programming languages class in
university, we wrote precisely one significant program in Haskell -- an interpreter for a simple
Scheme-like language (with proper
static variable binding, of course).
I worked out a beautiful design for the program, then wrote the program itself. Trying to compile resulted in several hundred lines of errors. Turns out that Haskell is whitespace sensitive in ways I hadn't realised (á la Python). So I fixed that.
Then it didn't compile for less frivolous reasons. 2 typing errors (the compiler was unable to find types for expressions) corresponded to 2 bugs. I fixed the bugs, and the program compiled; this entailed rewriting some of the code.
It still didn't recompile, but for idiotic reasons. Fixing those resulted in a compilable program. Unimpressed, I ran it.
It worked, first time, except for a silly bug in the connection between symbol names and builtins. I fixed that, tested 2 examples, and submitted.
Almost all errors had been compile time errors, not run time. They were unambiguous (since they didn't depend on the particular input of a run), and very clear. Evidently strong typing, lazy evaluation, and functional programming rulez!