Of course, that 'a g i l i t y' of dynamic typing is impossible to give up. The devs must churn out code ASAP, maintenance be damned -- mostly because they probably won't be maintaining it.
- Average tenure in a dev job being so short means it is detrimental to optimize for the long term.
- Promotion policies in most companies are heavily balanced towards "shipping more" rather than towards "shipping better". Even in companies without formal policies around this, "more" is way more visible than "better". Even more so if you get to be the hero firefighter who rescues the site from downtime, nevermind that it was your code that set the place on fire in the first place.
- Software as an industry has very low capital requirements, which makes it easy to get into. However, that also means competitors can spring up very quickly and many companies respond by constantly churning out features to stay ahead of the competition.
- It is IMO way easier to teach yourself programming with a dynamic language rather than with a statically typed one. Interpreters are certainly not exclusive to dynamically typed languages, but they are definitely more prevalent. With so many devs being autodidacts, it's not a surprise that many of them default to dynamic languages.
Don't you mean, constraints are found when the program throws an unexpected exception and leaves you with a largely meaningless stack dump :)
I'd rather have the system tell me "you can't do that" much earlier - at compile time, not run time.
I use python quite a bit, but hate the thought of all those never-exercised control paths, which only occur in the most unusual circumstances - and I know silly problems will show up when those paths do get executed :(
I'd love to see some examples of this. Links?
In "some cases" doesn't mean the statement is bs. Generally jit is slower than compiled code. There are exceptions to every rule, we use generalizations to reason about the world anyway.
In other words, if static types alone are giving confidence to refactor, it is a false confidence except in the most trivial of cases.
As a consequence, a lot of peoples primary experience with type systems is limited to "this should return a list of strings", which like you said, is one small class of problems (though I'd argue it's huge win compared to not having that guarantee).
Every project needs tests, but like all things, what happens in practice is seldom ideal and thus the more you can offset to (reliable) automated tools the better.
Simple, vanilla Haskell is approximated more and more by the mainstream languages: Optional types, andThen().orElse() and friends and other things - which I am really happy about!
Why not use a more mainstream langauge then? For me, there are at least 3 hard reasons:
1) The stuff mentioned above is old, battle-tested and deeply embedded into the language and the community - it feels ergonomic to use.
2) IO-being-a-library is a paradigm that produces programs that I love to maintain, also when others written them.
3) Haskell has nice interfaces that I miss in mainstream languages, Functor and Monad for example. My prediction is that in around 5 years, mainstream languages will start to offer these kind of interfaces - starting from "Wait, what else can we do with andThen() and optional chaining and so on?"