While I like benefits of strong typing system, there is one thing that worries me the most. I think of strong type system as means of forcing design choices. If a team builds a system unaware of its poor design, types will only reflect bad design choices.
For example, a programmer often finds he needs to access (hopefully only read) a variable not declared in type of the function. This function may be used in many places where this constraint was implicit and fine. A signature change triggers a snowball effect. Change escalates until it hits
main method or close to it. On top of that, we create a problem of compatibility and even merging becomes an issue.
In an impure (or object oriented) context, programmer will find his way to capture this variable. And I agree none of them will be pretty. But he can make progress without breaking stuff (most of the time). It's a form of technical debt, but people will (often rightfully) argue that it's beneficial to the project.
Has anyone experienced this kind of issues?