JavaScript is missing a stable base, packages, ABCs and interfaces, and a shared testing framework. However many of these are available within separate communities like for example the jQuery community. jQuery provides a stable base, plugins, a good community to share code, a standard testing framework, a way to extend code (plugins) to make it reusable, and now it has a module system which can be shared with other JavaScript frameworks.
I've been on 10+ JavaScript developer projects with 100+ developers over all. I've seen JavaScript code reused by one million+ developers. I've seen open source JavaScript projects with 100+ developers. So I have experienced myself that it can scale up to a certain point.
As long as the team has the best practice skills to do it that is. JavaScript is the ultimate spaghetti making machine in the hands of newbies without direction.
Well-thought-out code will always trump bad code; but that's a truism.
I'm not saying dynamic typed languages are better than static typed languages. Right now I use coq. I write programs and their correctness proofs so I definitely get why you would want some static guarantees.
You'll have more of the runtime errors in Python, but you're not free from them in other languages either, static typing or not.
As for the semantics of crashing vs. not crashing, that is a different argument entirely. Do you want your code to suppress a SyntaxError or TypeError exception and "keep going" - probably not? But maybe? It all depends, I suppose. You'll let the unhandled and unexpected exceptions percolate to the top of the stack and then your "main" method will decide what to do next. But putting square pegs into round holes do happen, and the question then becomes: how do you ensure that does not happen as often?
I never made the argument that languages like C#, Ada, Delphi, or Java were immune from runtime errors. Not at all.
As for strongly typed- yes, that is true, but it is also dynamically typed, and combined with duck typing you're left with a philosophy that encourages interchangeable types provided the interface is similar. Strong typing come in many forms, and you can have strong types and still have a compiler there to help you out. But of course, no system is perfect.
That's all well and good when you still have a complete, mental overview of the code and how it interacts at a macroscopic level. That's much harder to do when you go from 1 to many developers -- especially if you're developing code to be consumed by other developers.