This is a question I've thought about a bit over the years. I know it's one of those things that pushes people's buttons, so I hope here we can have a good discussion about it without any rude or insulting behaviour.
My take on it: I am not a huge fan of compilers. More specifically, I really dislike adding type annotations to code. It creates visual noise that makes the code significantly less readable. On the other hand, what about its value? It seems to me that if we have decent automated tests, which we should anyway, that should cover any kind of problem that a compiler might find at compile-time. Static type checking also adds extra boilerplate to code, in the form of things like interfaces, that we can avoid in dynamically-typed languages.
Now, type inference has become more mainstream in recent years, and that does help to reduce the visual clutter. I think it would be cool if, in addition to type inference, there was also an easy way to toggle the visibility of type annotations in source code. That way, one could use them as needed when editing the code, but there would be the option to just get rid of them when looking at code. If something like that were available for sites like github, that would be really cool. Does anything like this actually exist?
Languages like Rust bring a new dynamic to this question. In the past, I think languages that were compiled essentially did basic syntax and static type checking, and that was mostly it. Rust, on the other hand, actually does some analysis on the code and provides runtime guarantees around memory integrity. That seems like a much more significant added value to me, since it's not the sort of thing we get from automated tests, and it can be tough to find such issues just by inspecting the code. For now, I'm not sure I'd enjoy programming in Rust. It seems that one can tend to spend more time fighting with the borrow checker than actually solving real problems. If the borrow checker gets smarter, such that there aren't so many cases where the code itself is logically fine but the borrow checker doesn't realize it, I think that would provide a greater incentive for more people to start using Rust. It's definitely a cool idea.
What do you think? Do you find type annotations useful? Do they clutter up code or make it easier to understand? Are compile-time checks worth the trouble?