Comment by sharpercoder | Hacker News Reader

Comment by sharpercoder | Hacker News Reader

Parent Full thread

We do need better languages, but we should get rid of languages that marginally improve. Take CoffeeScript: it pushed EcmaScript forward, but does not offer enough feature today to justify pouring enourmous man-hour resources into it.

And this is true for many more languages (Flow, PureScript, LiveScript, IcedCoffeeScript, ...) which don't innovate on many aspects but just offer a slightly different - sometimes improved - syntax. I do recognize that many languages add value, but that must be offset to the cost of using these languages. Costs which are often quite high: Googleability, StackOverflowability, documentation, tooling, develop mindshare, library support, stability - these things don't come cheap and take years to mature.

Furthermore, these "innovate slightly" languages in the webspace take away resources from improving the current state of the art in mainstream (EcmaScript, TypeScript, Dart, C#, Java, ...). For instance, instead of improving some JS tool now resources go into e.g. writing a language server for aforementioned language.

A good example is Elm which does try to innovate on core concepts (builtin reactivity). That's a conceptual feature which can bring the state of the art of programming language design further.

Last, I do not mean that we should not write any more new languages; but we should stop trying to get large-audience adoption for "innovate-slightly" languages. It's a waste of braincycles and actually hurts the ecosystem.

PureScript is not JavaScript with a different syntax: it is a language with a full Hindley-Milner type system.

"A strongly-typed functional programming language that compiles to JavaScript -- Build real-world applications using functional techniques and expressive types, such as: Algebraic data types and pattern matching; Row polymorphism and extensible records; Higher kinded types; Type classes with functional dependencies; Higher-rank polymorphism" http://www.purescript.org

Came here to say this. PureScript has innovated enough to influence both Haskell and JavaScript. It is certainly a solid language in its own right

I understand the general sentiment, but the two categories you describe seem subjective to me.

For example, why do you consider TypeScript to be a "state of the art in mainstream" worth improving, and Flow to be just an "innovate-slightly" language? Those two projects are very close in nature. And if the key difference is adoption, then why is Dart along with EcmaScript and TypeScript?

Dart is an incredible achievement in terms of type systems tech. Gilad is a major inspiration for me. Great guy.

Idk whose "side" I'm on here, but I didn't want to lose an opportunity to blurt out my love.

It's a shame dart is being managed by google. I wish they had been more hands off with the dart team, as they are deviating from server-side go so people can write mobile apps in dart. Even though they'll look almost exactly like C# apps but with better types...

Anyways yeah. Dart. Cool types. Good vm. Gilad is a cool guy.

Can you explain why you think the type system in Dart is great (or point me to something on the web that does this) -- AFAIK, that has never been made a selling point of the language.

(I have been considering Dart for a while, but haven't taken the time to look into it because it doesn't seem like it provides additional benefits compared to other languages (apart from the Flutter aspect).)

So dart has the concept of gradual typing, where some portion of the program is annotated and the rest is not. I'm not completely up to date on current dart, but for some time there was the concept of checked compilation sms unchecked. Now I think it's called strong mode.

Anyways, you could check for certain major structural errors in unchecked mode and compile very fast, and then when it's time to start propping up a release, you can turn on checked mode and catch more intricate errors.

Gilad has been working on gradual/optional type systems for years. (they are technically two different ideas but the difference is rather academic and of little use to most programmers)

Anyways, dart has strong generics, it can do contravariance easily which makes refactoring code without breaking existing call sites, the dart lang spec has a great section on this.

In addition to all this, dart has really good reflection support through mirrors, a concept I'm not very familiar with, but it makes possible a tool called observatory, which is awesome. You can have source maps for dart2js, you can see which individual classes or methods or even lines of code are being utilized, you can get a lot visualizations about your performance profile, you can look at dart from the inside of dart. It's a lot like smalltalk, but way more practical.

Sort of like how rails took a perfectly good language and destroyed it, flutter seems to have built a foundation for taking dart and exploiting it.

Now they say its client-oriented" which I assume is googlese for "if you're not using dart for flutter, fuck off."

There was also a dart llvm effort at one point, but that became too useful and was abandoned.

If you are looking for a really good functional language for web, consider F# if you have dotnet experience, or bucklescript if you have ocaml support, scalajs if you have jvm experience and also love shitty tooling, and finally, purescript if you like haskell.

HN likes Elm a lot, but it's a little too opinionated for me, and although I like the BDFL approach to FOSS, it doesn't mean that you should be the ONLY developer in the core. That makes me exceptionally nervous about adoption, especially for professional work.

YouTube search for "gilad is right" for some talks that he's given. There's one where he dives in depth to the type system and how checking works.

Sorry for no links, literally using 2G right now, travelling.

Thanks for the extended explanation. Lots of things to chew on.

Yeah, I am unhappy that they are focusing Dart more on the client side (another reason, I didn't look too closely at it) -- focus like that is probably good for language adoption in some niche, but it would be nice to have a good strongly typed language that also has good support, good tooling and extensive libraries for use both on the client side and the server side (and for mobile app development!) so you have only one language to deal with everywhere. Dart is one of the few languages that from the outside seems closest to that ideal.

Yeah exactly. I've followed gilads work for more than a decade, but they have managed this project in typical Google fashion.

I'm kind of at the age where I'm just too far removed to try and work on learning a whole new field. If I could go back, I think I'd choose type theory and compilers and spent longer in college. Instead I learned to reverse software and built my career up piecemeal, but there is so much fascinating material surrounding compilers and the intricacies of how different type systems behave and allow modeling. I see how people get their whole career sucked up into that space.

F# still has a chance if dotnet can step their game up just a few more notches. They're getting better lately.

You will probably be disappointed to know that dart is fully statically typed now (with type inference). Still a good language but missing it's dynamic soul. I too thought that gradual typing was a perfect balance.

Oh no!

Well.

What is Gilad up to now, I wonder?

For such a talented researcher, that's gotta be demotivating for him. Bless him.

I guess dart is basically ceylon now but with contravariance? Gradual typing gave it such a unique space.

Gilad left Google last July and is now at Tensyr.

Source: http://bracha.org/cv.pdf

Man, I am way the hell out of date! Thanks for searching that, I appreciate the gesture, I could've just googled it.

I'm glad to see him in a position where he will be able to be more explorative though, that's gotta be a relief for him. I'm sure once flutter started picking up more engineers he probably knew then what the outcome would be and how his directional influence would start to be limited.

The categories are subjective but at the same time driven by a plethora of factors. The fact that TypeScript is developed by a large company means that it can overcome many barriers. Another factor is that the same company develops a new IDE (editor) in tandem; this means one of the most important parts of a language (tooling) is covered. A third factor of TypeScript is the many language features it offers. Fourth, the development pace is very high compared to most other projects. The "innovation factor" of TypeScript is combined quite high, as the "compile-to-readable-js", language features and tooling support combination is not achieved by many competitors.

Flow is a nice comparison as it is also backed by a large company. They don't offer a developed IDE in tandem, development pace is a lot lower and language features are not that many compared to TypeScript. The "innovation factor" is a lot lower - of the level I think it's not worth pouring resources into it.

Reply on news.ycombinator.com