[abhinav22]

Static typing is generally a good thing…I thought this was common sense.

Abstractions are very powerful, but when many people work on a codebase, keeping extra checks via static typing imo is good. Unless your Dev team is _highly_ experienced, then you can put away with the training wheels

[dang]

It definitely isn't common sense - it seems to be a matter of temperament. Some people like one way, some people like the other way. HN user luu looked deeply into the published research on this and found no strong indication either way.

https://danluu.com/empirical-pl/

The evidence behind strong claims about static vs. dynamic languages - https://news.ycombinator.com/item?id=16287083 - Feb 2018 (1 comment)

The Empirical Evidence That Types Affect Productivity and Correctness - https://news.ycombinator.com/item?id=8618887 - Nov 2014 (17 comments)

The empirical evidence that types affect productivity and correctness - https://news.ycombinator.com/item?id=8594769 - Nov 2014 (9 comments)

[abhinav22]

Thanks for the link, I will have a read

[alpaca128]

Static types aren't training wheels, though. They're seatbelts. Without it the same type checks still have to be done, but this time by humans. And experience doesn't make them much more reliable at manually doing tedious checks.

[diragon]

>Without it the same type checks still have to be done, but this time by humans.

Nah, they don't have to be done. Most programmers using dynamic languages just don't think about types until they need to be thought. That implies there's more resources/energy available to think about the actual problem, which often has almost nothing to do with types. Then if you're using something like Common Lisp/SBCL, you can define the types afterwards where they are most critical.

Doing all this well in a dynamic language requires more discipline obviously, since you cannot even release software in a stricter static language if it fails to pass the type checking phase. But it is faster, sometimes significantly faster. Sometimes it may even happen that the coder could not have finished the task in a stricter language, which would imply that the the dynamic language was infinitely faster.

[yxhuvud]

Static types can also be a straitjacket. Type systems have improved greatly over time though, so the balance is shifting. The world is not stuck at the point in time (2003) when the article was written, and type systems in general use have improved a lot with both more flexibility, protective power and less bloat.

[go_elmo]

It is just a part of automation to have a static type system, instead of having to do it manually which is the worst task for humans (tedious and error prone). Everyone having to use some python code consisting out of 4 half-baked libraries can confirm - it is a nightmare, at least for me!

[nielsbot]

It's good, with limits. There should be escape hatches to allow dynamic behavior when the static type system is too limited. (Consider Swift's "protocol with associated types" nightmare.)

[IshKebab]

Yeah you'd think that it would be common sense but a lot of people can't get past the fast that they have to write more stuff. I would guess because it is hard to understand the benefits until you've actually used a statically typed language, and a lot of people start in dynamically typed languages (Python, JavaScript).

And as someone else said, static types aren't training wheels. You don't stop using them when you think you're sufficiently skilled.