You can use arrow keys to navigate in the map.
Static typing allows compilers to optimize in a way that is hardly achievable with dynamic typed languages
Programming tools like IDE's can provide a richer set of supporting features or they are more sophisticated. Mainly regarding refactoring, suggestions, debugging, metrics, detection, prove, inspection, documention, generation, build,...
It is easier to detect and fix compile-time errors than runtime errors.
Static typing serves as reliable documentation.
Dynamic typing languages are much easier to use, learn and faster for prototyping.
Type systems can sometimes forbid valid programs, especially if a the type system is not very expressive.
Static type-checking prevents silly and easy to fix mistakes early enough that could be troublesome to fix in the future.
They are harder to use on prototyping stage when you are discovering what actually you need to write. That's why language with optional static typing (like TypeScript) are the best of both worlds. You can prototype without types and add them when you have discovered what you need.
Typing is merely one check that can be performed. A comprehensive test suite provides a lot more confidence in the code, and minimises the effectiveness of the type checking.
Developers can focus better in the domain problem using a dynamic typed language because they do not need to worry for pleasing the type-checker
Depends on your application. One is not better then another in each and every case.
Dynamic typing has easier access to meta information. This has advantages and disadvantages, like monkey patching. It's more difficult to realise in static typed languages (for compiler creators), but does exist in form of Reflection.
Types are easy to convert from one to another in dynamic languages.
Static typing need to cast.
statically typed languages come with overhead that often would be better put to use on testing, documentation, architecture and most importantly new features.
Static types help you craft a domain model that is logical and consistent.
Static typing leads to large codebases with more files and classes compared to dynamically typed languages. It also forces the continual creation of logic which has nothing to do with the actual problem being solved. And which have to be maintained too.
It encourages the programmer to actively consider the type of an object at and prior to the point of creation, and thinking about what you're doing in advance is strongly correlated with higher quality code.