[ts330]

hard to fathom there's an entire generation of developers out there for whom this is entirely new magic. there's an entire class of problem and suite of (bad) tooling that they're having to grapple with to deal with things that simply aren't issues in statically typed languages.

[davedx]

As someone who spent a good 8 years doing development in static languages and then the next 8 or so doing mostly JavaScript, I do occasionally miss the superior tooling available in static languages - and yet, I’m more productive in dynamic languages. This isn’t just experience, I occasionally still write Java and Scala code. But dynamic languages are sufficiently more powerful that the trade off with tooling is worth it.

In Scala the compile time alone is a massive drag.

[bitwize]

Are you more productive according to the stopwatch? Or do you just feel more productive?

I believe that a strong static type system with generics is an unmitigated win, and that any time you think you may have lost fighting the compiler is more than regained by the time saved not having to track down type bugs at runtime, using the IDE to perform code completion and refactoring, etc. This effect is magnified as the project grows large.

[softawre]

You could certainly use Clojure in the JVM like Scala/Java.

Or Kotlin for both front/back with transpilation to JS.

[always_good]

Dunno, I'm not convinced this is "new magic" for anyone nor that you can learn to program without at least encountering static typing.

It's just that dynamically-typed languages are still popular. And Javascript continually grows and is often a good choice, like for client-side applications. So it's not time wasted if we can figure out ways to improve the tooling experience for these languages.

For example, there are just other considerations beyond static-typing when choosing a language. It seems condescending to suggest that people are unaware rather than just picking different trade-offs.