you can link statically typed libraries into dynamically typed languages without too much heartache by creating wrappers. Statically typed languages are favored for large programs because static typing enables vastly greater understandably by making every function have basic, front facing guarantees of what it will accept as input. These give you strong assurances about what the function you're calling does and does not do, letting you fluidly write using code without having to analyze if what the function is doing is safe with the types that you're passing in (which may not even be clear depending on what level of abstraction you're at in a dynamic language).
With dynamic languages, you have to either blindly trust or manually verify that a function will operate in a sane matter on the types that you're passing in. It creates a yoyo effect of going up and down and up and down and up and down multiple layers of abstraction just to make sure what what you write isn't going to bomb out at runtime. Remember this also might be in the context of 10 or 20 other coders that may not even be competent in their jobs and you have to use whatever they wrote. Static typing gives no guarantee of correct behavior, but the
scope of mistakes you can make is vastly narrower.
Reiterating: the problems i mention here are not a big deal for small scripts. Flexible code and manual verification is not a major hindrance if the code remains small. As the code expands and (more importantly) becomes deeper, adding features gets rapidly more difficult.
compiling and interpreting are vastly different. Compilers treat generic code as a template for making new code (hence the name in C++). They will actually generate copies of those functions for each type that you end up using. This enables the compiler to do static analysis on that code ahead of time as if the generics were never there in the first place.
Interpreters with dynamic languages have no such advantage because nothing is known before runtime. There ARE some interpreters that play out possibilities for what types
could be based on what they see for literal declarations, but doing this comprehensively in the program is completely infeasible as it would require every piece of code to try every permutation of every possible combination of types... and even then it would not be helpful because the compiler has no realistic way of knowing what you even plan to pass in from... say... a file or the command line. It would just be flagging random stuff that you never intended to do.
the simplest example of why code analysis fails for dynamic languages is this: say do_a_thing succeeds on numbers and fails on strings (being generous to assume it would know that to begin with).
Python:
var = 0
if some_conditon:
var = "hello"
else:
var = 5
result = do_a_thing (var)
What does the static analyzer make of do_a_thing? Does it force itself to evaluate both true and false conditions of the branch? Perhaps it could give a warning that the top branch would result in an error. But what about this:
Python:
var = read_json(root)["var"]
result = do_a_thing (var)
