I've long been loath to write any contributions on the debate between static and dynamic typing in programming languages. This is one of those emotive topics where people seem driven to debate rather than listen. But since I've been asked a few times about it, I will contribute my personal experiences. I'm not trying to convince anyone of anything, but I hope someone finds some food for thought in them.
When I first conscious of the distinction I was quickly convinced by the advantages of static typing. My early experiences of programming were in Basic and Fortran IV - where the typing was limited. I then moved to Pascal and that quickly became a language I enjoyed programming in.
When I got into objects I worked in both C++ and Smalltalk. For quite a while I saw Smalltalk's dynamic typing as a disadvantage - a small price to pay for the otherwise wonderful productivity of the platform.
I really began to question this when I got involved with some moderately sized Smalltalk projects. The general argument for static types is that it catches bugs that are otherwise hard to find. But I discovered that in the presence of SelfTestingCode, most bugs that static types would have were found just as easily by the tests. Since the tests found much more than type errors, you needed them in either a static or dynamically typed language, so having the static typing gave you little gain.
It's been interesting to see others follow this line of discovery. Both Robert Martin and Bruce Eckel have found the same thing coming from C++ to Python.
However catching bugs isn't the only benefit to static typing, and it's some of the others that I find more noticeable these days.
One day I found myself trying to follow some well-written Ruby code. I found the lack of type information on parameters made life difficult - I kept saying to myself 'what exactly do I have here?' I didn't find this so much of an issue in Smalltalk for two reasons: the excellent environment makes it easy to fire up a debugger and see what you have, and secondly the common convention is to name the arguments after the type. (This makes sense because Smalltalk has keyword parameters rather than positional parameters, so the keyword explains the role the parameter plays.)
Another area where static typing is useful is that it allows programming environments to be much more helpful. The revelation here (as in so many things) was IntelliJ. With an IDE like this I really felt the type system was helping me. Even simple things like auto-completion are greatly helped by static types, and leading IDEs can do much more than that.
Despite this, there's still something particularly satisfying about programming in languages like Smalltalk and Ruby - and I think it has a great deal to do with the dynamic typing. Chatting at Camp 4 Coffee with Bruce Eckel we both agreed that one of the most frustrating things about the static/dynamic typing debate is that it's very hard to put into words the advantages of working in a dynamically typed language. Somehow things just seem to flow better when you're programming in that environment, even when I'm doing my Ruby in emacs instead of IntelliJ. (Smalltalk, of course, has both the language and a lovely programming environment.)
I suspect part of this is that the conciseness of the language allows such things as doing a DomainSpecificLanguage in the language. Working with languages such as Java and C# I always feel the need to skip over text in order to understand what's going on.
Whatever the reason, this better flow leads to more fun programming - even with an inferior environment. This may not seem to matter much, who cares if programmers have fun? But I do care because I really enjoy programming. I enjoy doing things quickly without having to futz around on guff that gets between my thinking and running code. For me that's the pleasure of Smalltalk and Ruby and why I reach for these on any personal projects. And there's business value in fun - after all motivation is a major factor in programmer productivity.