Hacker News Reader

Comment by tootie | Hacker News Reader

Not to be a grump, but if you were using a staticly-typed language with any half-baked IDE 20 years ago, this behavior was available.

View on HN

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.

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.

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.

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

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

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.

Not grumpy at all. Of course you are right but solving this problem and making features like this available in dynamically typed languages is a bit tougher and in some cases, not at all possible as certain things might only be known at runtime.

So intellisense news in an IDE is certainly nothing new but it is "newish" for more functional/dynamic languages like JS. JetBrains has also done a good job with their intellisense in their IDEs for Python and Ruby, for example.

Any plans to make JavaScript (the standard) strictly typed? (I know about TypeScript, etc.)

ES4 tried. Typescript, Flow, and ActionScript's type annotations all inherit almost directly from ES4 (though each diverged to different paths).

I think the next step would be to see someone champion through TC39 the "Python model" where browsers/engines should at least parse and ignore type annotations per spec. Then at least you could pass Typescript/Flow annotated code directly to a browser, even if the browser/engines don't immediately do anything with those extra annotations.

This * 1000. I believe there were some proposals but they never made it past strawman proposal.

Just interface {}, as Y, and :type annotations in JavaScript would take us very far.

On that note, how does one even submit an ecmascript proposal?

Reply on news.ycombinator.com