| Cost matters, but in my experience there's more to this story. It's more like this: "write 99% correct code in 1 week and then try to fix it as you go, but your fixes often break existing things for which you didn't have proper tests for. It then takes you total of 2 years to finally reach 100% correct code." Which one do you choose? It's actually not as simple as 1 year vs 2 years. For a lot of stuff 100% correctness is not critical. 99% correct code can still be a useful product to many, and to you it helps you to quickly validate your idea with users. However, the difference between static and dynamic typing is not that drastic, if you compare dynamic typing to an expressive statically typed language with good type inference. Comparing, for example, Python to C++ is not really fair as there are too many other things that make C++ more verbose and harder to work with. But if we compare Python to for example F# or even modern C#, the difference is not that big. And dynamic typing has a costs too, just different. 1. "Story" can be harder to understand without "metadata" due to ambiguity that missing information often creates. It's a delicate balance between too much "metadata" and too little. 2. Too much composability can lead to bugs where you compose wrong things or in a wrong way. Generic constraints on interfaces and other metaprogramming features allow flexible and safer composability, but require a bit more tought to create them. 3. Reuse is similar. No constraints on reuse, doesn't protect you from reusing something in corner case where it doesn't work. 4. (depends on how you design your types) 5. Dynamic languages require you to write more tests. 6. F# and C# for example both have REPL. Quality statically typed language is much harder to create and require more features to be expressive, so there are less of them or they have some warts and they are harder to learn. It's a game of tradeoffs, where a lot of choices depend on a specific use case. |