I suppose. But it’s also true that you should minimize the number of debilitating medical conditions you’re suffering from long-term.
Which brings us back to the thing where we end up having to choose between a chronic condition which is heavily correlated with a whole bunch of secondary health problems and reduced life expectancy, and being on a drug from which we have not (yet) observed long-term ill effects.
The back-of-the-envelope life expectancy calculations were mostly just there to point out that under most plausible assumptions, the risk/benefit calculations seem lopsided to the point where it shouldn’t be a terribly difficult decision.
I like type checkers less because they help me avoid errors, and more for ergonomics. In particular, autocomplete—I feel I code much, much faster when I don’t have to look up APIs for any libraries I’m using; instead, I just type something that seems like should work and autocomplete gives me a list of sensible options, one of which I generally pick. (Also true when it comes to APIs I’ve written myself.) I’m working on a Unity project right now where this comes in handy—I can ask “what operations does this specific field of TMPro.TextMeshProUGUI support”, and get an answer in a half a second without leaving the editor.
More concretely than that, static typing enables extremely useful refactoring patterns, like:
Delete a method or change its return type. Find everywhere this breaks. Fix the breakages. Now you’re pretty much done; in a dynamically-typed language you’re reliant on the unit test suite to catch these breakages for you. (All the places I’ve worked have done unit tests, but generally not above somewhere around 80% coverage; not enough to feel entirely safe performing this operation.)
Refactor/rename becomes possible, even for methods with possibly-duplicated names across your files. For instance: renaming a method named “act” on a class you’ve implemented requires manual effort and can be error-prone in Javascript, but is instantaneous in C#. This means you can use refactor/rename compulsively any time you feel you have come up with a better name for a concept you’re coding up.
I kind of agree with the article posted that, in general, the kinds of things you want to demonstrate about your program mostly cannot be demonstrated with static typing. (Not always true—see Parse, don’t validate (lexi-lambda.github.io) -- but true most of the time.)