Hacker News Reader

Comment by adamors | Hacker News Reader

I really fail to see the point of Dart, especially since awesome client side frameworks like Angular already exist.

Why doesn't Google throw more resources at them instead of creating something from scratch that has a very high possibility of being abandoned in the next 2-3 years.

View on HN

Because writing/improving yet another JavaScript client side library fails to address the fundamental flaws with JavaScript which are well laid out. ECMAScript 6 will likely correct some of these flaws, but the necessity for backward compatibility continues to be a stumbling block. Dart is a clean break and fresh slate while retaining a familiar syntax and interoperability/compatibility.

Is it a long shot that it will unseat Javascript? Sure. But, competition is good for JavaScript. Google's number one interest is in improvement across the entire client side web app infrastructure since its business is built upon it. It can push Dart while improving JavaScript in parallel.

I definitely agree that JS itself could be improved, but while Dart improves some things, it makes others a lot worse. Look at the Fibonacci program on dartlang.org, and compare it to any language that's popular with web developers: Python, ruby, Coffeescript or even scala. Multiply that unnecessary overhead for every function in your app.

You mean the graphical one where they use storage, forms, and events? Let's not be misleading... Hello World in Dart is: main() { print("Hello World!"); }

> main() { print("Hello World!"); }

Yes, that's my point. Why not just print("Hello World!"), like everything else?

The top level of a Dart program is a group of definitions, like in Java or C#, instead of a series of imperative statements. That makes it easier for static analysis, since you don't have strange constructs like:

    if (itsTuesday) {
      class Foo {
        ...
      }
    }

It also means mutual recursion just works, without weird semantic shenanigans like hoisting in JavaScript. In Dart, the top-level is "simultaneous": all of those definitions are static with no mixing of side-effecting imperative code at the top-level which would make ordering matter.

The main side-effect of this approach is that you have to wrap your entrypoint imperative code in a main() function. It's a pretty small price to pay, especially in an application with thousands of lines of code.

Personally I don't mind hoisting but for the moment, OK. So obvious question: why doesn't the language create this entry point for me?

Because once you allow statements at the top level alongside declarations, which statement should be run first? main() makes that clear.

In JavaScript it depends on the order of script tags and their attributes. It's really hard to determine what code is actually run at application startup, and what the initial state is.

Making the top-level only declarations means that the programmer knows what code runs first (the first line in main()) and the VM knows that the order of evaluating the declarations doesn't matter. It can evaluate them all and cache the result so that subsequent runs are fast, it can execute main() before other declarations and evaluate them on an as-needed basis, or something in between.

Convention? I guess it does comedown to function hoisting in the end, so the expectation is the body of code after the functions are defined / function variables created. I think a lot of people prefer that convention over boilerplate code, and the tide of language development seems to be heading in that direction.

OT: script tag soup is, for first party stuff anyway, avoided with a single script for a module loader these days.

One big advantage of top-level declarations is it is possible for the VM to use a snapshot for fast start up.

This is not really possible if you must interpret top level code to build up your top-level declarations, as done in JS.

Using snapshots, the Dart authors have said it should be possible to improve script start up time by 10x over V8. This is a big win for large script heavy apps.

Edit: link https://www.dartlang.org/articles/snapshots/

If you allowed top-level imperative code to mix with non-imperative definitions, it gets really semantically squishy. Top-level variables in Dart are lazy-initialized, which lets their order not matter. But variables in imperative code are initialized at definition time. How does the language tell which one it should prefer if it allows both at the top level?

Also, if you import a library that contains this top-level imperative code, how do you invoke it? Is it invoked automatically? When? How does that play with cyclic imports?

The small amount of overhead of a main() method solves all of that.

main()=>print('Hello World!');

...parent changed comment from complaining about Hello World having too much boilerplate in Dart to being about something else entirely. This is why HN should not have an edit feature...

I thought dartlang.org had a helloworld, instead it had a fibonacci. I updated to show an example people could see. Not sure why that's an issue.

If you're changing the message of your post, annotate it with an Edit leaving the original message in-tact, especially if it's found to be non-factual.

Here you're invalidating all responses and making them sound non-sensical. Post a new message if you have something new to say.

I'm not changing the message of the post. The only difference is the demo referred to. The point about Dart being too verbose made remains the same in both 'hello world' and 'fibonacci' cases as you can see, it was simply a matter of being in a cafe using a mobile phone where switching out to another tab, opening the golang site and finding a demo to check that they had the 'hello world' example most sites provide was difficult.

The person attacking me for 'changing' my post has been on News.YC (ahem 'Hacker News') for 70 days, called criticism of the boilerplate code shown in the Dart demos 'FUD', and wrote three separate replies to the same point. Judge for yourself.

Right because length of existence of a username is really a good argument of anything...

All of your posts attacking Dart are for nonsensical reasons, and then your replies are backsteps admitting part of what you originally said was wrong and then coming up with a new nonsensical argument. I don't know what you have against Dart, but your basic premise that it's verbose is absolutely wrong. They've actually taken pains in the syntax to not be verbose (factory constructors, => functions, getters and setters, .. syntax for cascades, etc). It just shows you judge the language based on glancing at the front page of the website for 2 seconds without doing significant reading. In other words your posts are FUD. I stand by that.

> because length of existence of a username is really a good argument of anything

Yes, if the user is lecturing others on HN etiquette.

> All of your posts attacking Dart are for nonsensical reasons

If you think terse syntax and good quality documentation are nonsense then you are welcome to think so, I wish you the best of luck.

All of your examples of non-terse syntax were wrong though buddy... And it's clear you haven't read the documentation :)

> All of your examples of non-terse syntax were wrong

Cool. Send a pull request to the dartlang.org maintainers and they might fix it. ;)

In reply to your new comment about fibonacci. If you look at the actual function doing fibonacci, it's the same length as the equivalent fibonacci function in Java or Javascript... please stop spreading FUD.

The boilerplate is the issue, saying to ignore it is illogical. Unless it's not actually necessary in dart (mraleph says something in another comment) in which case it shouldn't be in the docs.

I have no interest in or against Dart other than wanting to see a compelling modern alternative to JS. Not sure why you think criticising Dart and it's website is 'spreading FUD'.

Fibonacci function in Dart can be as easy as:

fib(n) => n < 2 ? n : (fib(n - 1) + fib(n - 2));

Examples on the main page just exists to show cases as much language features as possible. It does not say that you have to wrap your Fibonacci into a class.

Maybe it's a matter of bad docs giving the wrong impression then? Examples should be terse, the ability to create unnecessary wrappers don't seem like much of a feature to show off.

Strictly speaking it's not a doc. It's a snippet on the main page that tries to show case available language constructs. I do agree however that wrapping Fibonacci in a class looks a bit strange.

Documentation that showcases features in the terse form is available at http://synonym.dartlang.org/

If you have better ideas you can file a bug or even submit a pull request for the site: https://github.com/dart-lang/dartlang.org

Web pages showing people how to do things are documentation. No inclination to contribute, Google have known that verbosity is a common reason for disliking Dart for 750+ days and haven't done much about it. I'm fine using JS and, when I want strong typing, know that Typescript is there.

Yeah, I think the Fibonacci class example is odd too.

I also would love to propose a self-imposed internet-wide ban on the recursive Fibonacci implementation as I'm pretty sure it causes brain rot and makes dynamic programming seem way more magical than it is.

>fib(n) => n < 2 ? n : (fib(n - 1) + fib(n - 2));

+ the laziest way to do memoization:

var cache = new Map();

fib (n) => cache.putIfAbsent(n, () => n < 2 ? n : fib(n - 1) + fib(n - 2));

Still seems like throwing the baby out with the bathwater to me. Especially since its from Google; as it is, it looks like the second coming of ActiveX to me.

It's a legitimate concern until you dig beneath the surface of the politics. The fact is that in the near future Chrome will not achieve IE 6 like market share and therefore Dart will primarily be used through Dart2JS. It's a legitimate fear for the future - but that's admitting then that Dart is a darn good step in the right direction and will see high adoption. At this time it's more of a straw man.

Also Google has said they will submit Dart to a standards body. That was never going to happen with Active X. And of course, unlike ActiveX, Dart is open source - so if in a pinch Dart took over the world super rapidly and the other browsers had to incorporate it...

I think without Dart2JS this would be a non starter. I can't see Apple or Microsoft implementing a DartVM either an open source one or one of their own, remember the Flash Player was an open spec but no one wrote their own.

> I can't see Apple or Microsoft implementing a DartVM ...

That's the whole point of Dart. Apple and Microsoft are protecting their closed platforms. They are not interested in open platforms like Web.

Microsoft improved IE JS engine after they lost significant market share. And please compare features of C# and ECMAScript.

Google pushed the whole web platform forward. I don't want them to wait for Microsoft acceptance!

> Google pushed the whole web platform forward.

Really? When do you expect other browser vendors to adopt DartVM and PNaCL?

This is the second coming of IE, nothing else.

> This is the second coming of IE, nothing else.

Completely Baseless, opinionated, inaccurate, hyperbolic, HN comment, check.

This is all just nonsense. Apple helped pioneer a second wave of innovation in the web with their efforts on WebKit. And they are still actively working on it as well as being active members of WHATWG et al.

Google is NOT pushing the whole web platform forward. They are pushing THEIR web platform forward. We saw it with SPDY and now seeing it again with Dart. Technologies developed in isolation that only see traction due to the popularity of Chrome.

Apple pioneered webkit to kill flash, I don't think they are that bothered anymore and I expect we will see them drop off in terms of browser development and holding up standards.

Sometimes the only way to push things forward it to do it in isolation, make leaps and bounds, and then present it as an open standard.

I totally agree on that. What makes Dart better than, for example, GWT or Coffeescript? In the end of the day, it's just a new language targeting JS. And that new language is doesn't have any advanced or interesting features except for the name of the company that created it.

JS is one aspect of Dart. Using the same language server side is the other. It really seems like a competitor of JS/NodeJS. They do have the challenge of convincing the JS world that the new system is better enough to warrant learning a new language. If it succeeds, it will be interesting to see if it is the Web side or the server side that drives adoption.

Dart's better than GWT because it's a modern language that is actually designed the be compilable to JavaScript. Not all of Java is compilable to JS, so GWT is really a subset of Java, but it's still verbose. Dart's much more concise and easier to translate to JS, so it's compiler is much faster too, but also adds getters and setters, mixins, operator overloading, implicit interfaces (every class defines an interface), top-level functions, optional typing, (and things Java's just gettgin:closures, collection literals). Dart and it's core libraries being designed for a single-threaded, asynchronous world is a big deal and makes it much more at home in a browser than Java. Where they're similar is in the ability to have tools and libraries that work well together, and mostly sane semantics.

Dart's better than CoffeeScript because it dramatically improves on the semantics of JavaScript. Libraries, classes, interfaces, mixins, only explicit type conversions, lock scope, privacy, no monkey-patching, fixed this binding, final, constructor initializers, optional typing... these are all things that make large programs easier to manage, and tools easier to write. CoffeeScript offers a couple of minor fixes like this binding, but basically is just a different syntax for JS. If Dart were just a different syntax, it wouldn't be worth it, but spend some time with the Editor (or WebStorm) and see the static warnings and errors, refactoring, code-completion, code navigtion, etc. and you'll see how it's miles better for teams.

AngularDart does now exist – http://news.dartlang.org/2013/11/angular-announces-angularda..., I wonder if that is going to be the direction that Angular is taken?

The problem with angular here is that it eliminates tree shaking in the dart compiler. Angular has the same problem with closure as well. tis a big problem imo which the framework creators best fix.

It is being worked on apparently: https://news.ycombinator.com/item?id=6731385

So far it's not clear cut.

When Angular.dart was announced, some people claimed that it would become the default version, and that features would be backported to the JS version. There were strong rebuttals from googlers, but IIRC none of which from the Angular team itself.

For v1.2, the Angular.js team has rushed the backport a controversial feature[1] from its .dart counterpart three weeks before release, months after the first RC was released, breaking the meaning of a release candidate.

:-/

1. the underscore prefix to make $scope fields private.

Dart is a language and VM, not a framework.

A framework aids your development and provides tools, it doesn't fix shortcomings in language and runtime.

FYI - the Angular team have ported Angular to Dart.

Reply on news.ycombinator.com