I'm a big fan of PHP and it's obviously a very weakly-typed language. I realize some of the benefits include the general independence of changing variable types on the fly and such.
What I'm wondering about are the drawbacks. What can you get out of a strongly-typed language like C that you otherwise can't get from a weakly-typed one like PHP? Also with type setting (like double($variable)), one could argue that even a weakly-typed language can act just like a strongly-typed one.
So. Weak-type. What are some benefits I didn't include? More importantly, what are the drawbacks?
I have been using both strong typed (like Java) and weak typed (like JavaScript) languages for some time now.  What I have found is that the convenience of the weak typed languages are great for small applications.  Unfortunately, as the application grows in size, it becomes impossible to manage.  There becomes too much to keep track of in your head and you have to start depending on your IDE and the compiler more and more or your coding grinds to a halt.  That is when strong typed languages start to become more useful - with the application grows very large.
Two examples that constantly drive me nuts in the weak typed JavaScript are using external libraries that are not thoroughly documented and refactoring.
External libraries: When dealing with a strongly typed language, the code from the library itself provides self documentation.  When I create a variable of type Person, the IDE can inspect the code and tell there is a getFirstName(), getLastName() and getFullName().  In weak typed languages, this is not the case as a variable could be anything, have any kind of variable or function and have function arguments that could also be anything (they are not explicitly defined).  As a result, a developer has to lean heavily on documentation, web searches, discussion forums and their memory of past usages.  I find it can take hours of looking things up in JavaScript for external libraries while with Java I just hit the "." key and it pops up all my options with documentation attached.  When you encounter libraries that are not 100% fully documented, it can be really frustrating with weak typed languages.  I recently found myself asking "What is argument 'plot' in function 'draw'?" when using jqplot, a fairly well but not completely documented JavaScript library.  I had to spend an hour or two digging through source code before finally giving up and finding an alternative solution.
Refactoring: With strongly typed languages, I find myself able to refactor quickly by just changing the file I need to change and then going to fix the compiler errors.  Some tools will even refactor for you with a simple click of a button.  With weak typed languages, you have to do a search and then replace with care and then test, test, TEST and then test some more.  You are seldom entirely sure you have found and fixed everything you broke, especially in large applications.
For simple needs and small applications, these two concerns are minimal to non-existent.  But if you are working with an application with 100's of thousands or millions of lines of code, weak typed languages will drive you nuts.
I think many developers get upset about this and turn it into an emotional discussion is because we sometimes get it in our heads that there is one right and one wrong approach.  But each approach has its merits - its own advantages and disadvantages.  Once you recognize that you set the emotion aside and choose the best for you for what you need right now.
What are the benefits (and drawbacks) of a weakly typed language?