Dart Website Relaunch with 1.0 Release | Hacker News Reader

Dart Website Relaunch with 1.0 Release

dartlang.org

84 pointsallanberger120 comments

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.

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.

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.

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.

FYI - the Angular team have ported Angular to Dart.

Awesome congratz to the Dart Team on shipping a quality product to the world!

Really hope they're able to keep investing in Dart, they've got an amazingly talented team and IMO Dart's one of the few languages in recent times with the engineering prowess and right focus on fast iterative development, speed, simplicity, flexibility and consistency that's pushing comp-sci forward.

"pushing comp-sci forward"

nit - The Dart team have explicitly said that they are not doing any features based on new computer science research. The Dart project is built on pragmatic engineering decisions, rather than "pushing comp-sci forward".

This is a good thing in my opinion.

The biggest announcement for me is that the Dart VM will be embedded inside Chrome: https://twitter.com/dart_lang/status/400915745413939200

I thought this was always the plan, which would make Chrome a must of people using Dart apps. Question is if other browsers would include the DartVM (I guess Opera will) or if they will rely on the JS version.

Yes, this was spoken at Google IO, in a talk where it was mentioned plans about merging v8 and dartvm.

Sometimes it pays off to watch the sessions. :)

But only Opera and Chrome use v8 as of now.

Yeah, but I was speaking about developer sessions in general, regardless of the technology.

A good developer should try to get as much information as possible about his/her tooling.

I remember the days where all I could learn about computers was trial and error, helped by what the local library could offer, if anything.

I can't imagine Mozilla or Apple adopting Dart unless it is ratified as some standard where they have the ability to contribute to its future roadmap. Apple in particular was burned by Flash and I can't imagine being willing to go down that path again.

This has sadly the potential of making Chrome second coming of IE6, with enterprises locked in a system that is too successful to have the incentive to evolve.

As long as the Dart specification is not governed gy a body encompassing all major browser vendors, this is a very dangerous development (And yes, I know that being governed by a standards body seriously hampers the evolution of a standard, but everything is a tradeoff...)

Such uninformed comparisons are getting extremely tiresome and I consider to be the enemy of progress. There is nothing more that the Dart Team can do to make it anymore open - they're doing as much as is possible.

This is nothing like IE, which is actually proprietary and closed-source. In contrast, there is absolutely nothing about Dart that's proprietary. Dart is 100% open source, including patents grants, it's completely developed in the open and for the last 2 years has seen steadily progress with feedback from the public mailing list. It's actually a goal for the project that everyone is able to freely use Dart in any capacity. Lars Bak already said that after 1.0 is shipped they're going to work on getting the language standardized. There is nothing legal or technical stopping other browser vendors using Dart, any hesitations are 100% political.

Dart is finally the first real alternative where we may be able to progress beyond JavaScript, that as a core objective also compiles to first-class JavaScript, i.e. many features dismissed because it couldn't be efficiently transpiled to JS. I care about progress, the current state of web development is fragmented and broken, we need to be encouraging more initiatives like Dart that challenges the status-quo and is able to progress past the fragmented inconsistent mess we have to deal with now in trying to develop complex, rich, high-performance web apps.

The problem is that even if Dart is completely open and patent free (and I agree that there is a vast difference between Dart and ActiveX in this regard), if the other browser vendors like Microsoft, Apple and Mozilla don't pick it up, it will still be a walled garden, even if the wall is built by the others.

Also Google has shown signs of embrace, extend extinguish when it comes to essential parts of Android, which makes me a bit wary.

I would love nothing more that Dart superseding JS as the goto language (and compile target) for browser development, as it is doubtless a step forward. But there are pitalls hidden on the way there and the outcome is determined by the path we will take.

Of course hesitations are political, because the outcome will be determined by political actions of everybody involved, Google, MS, Apple and Mozilla. Technical merits alone don't guarantee a happy outcome, sadly.

Agreed, although it's not a walled garden when others are artificially putting up the wall, since they continue to enjoy the complete freedom if they ever want to take it down.

Luckily unlike other walled gardens, the quality of Dart2JS, i.e. first-class source-maps support and many benchmarks showing it even outperforms hand-crafted JS, ensures that Dart apps will continue to benefit and run in other modern browsers even without their support, where the only difference will be the start-up and runtime performance of the running code, so we end up getting it back down to technical merits.

How are Mozilla and Apple putting up a wall ? Dart maybe open source but it still a proprietary, non-standard solution where ALL the committers work for Google.

https://code.google.com/p/dart/people/list

Please re-read the parent, I've replied saying it's not a walled garden when others are choosing not to adopt it.

> Dart maybe open source but it still a proprietary, non-standard solution

You use the word 'proprietary' but I don't think it means what you think it means. It doesn't mean you have complete access to the entire source code implementation and freedom to use all of it or any of it, in anyway you see fit. It doesn't describe a project that's driven by feedback in a public mailing list, that welcomes external feedback and contributions, and it's rarely used to describe a project with a core goal for it to have no-legal-or-technical-barrier, free access, encouraging its wide-spread adoption.

By your definition most Open source projects are proprietary and non-standard, where most programming languages aren't even standardized, the difference with Dart is that it actually has the commercial backing that can justify the effort in actually getting it standardized, which it plans to do now that Dart 1.0 is shipped, just as Lars Bak announced at Google IO.

Again like many OSS projects, the Dart project has taken external contributions, but the brilliant minds that Google have brought in to work on Dart full-time are indeed being paid to do so. It's not uncommon, to accept Q/A verified external contributions but to ensure only employees have free reign and project-wide commit access. Even Dart's internal contributions still have to go through a Q/A code-review process.

Dart is quite awesome on technical grounds. One thing though. I'm not entirely sure how it combats fragmentation. For example, I also find TypeScript awesome. ECMA6 fixes most of the blind spots of JS and it's quite palatable. Heck, even Java 8 is getting in the same general sweet spot. In another neck of the woods we have iOS. So now there are 4-5 solid platforms (language + libs) with sizable corporate support to develop Web / mobile apps. Oh, and there is also pNaCl (technically awesome as well), which raises fragmentation by an order of magnitude. I find the situation bewildering. Coding in all these languages and platforms is pretty much the same, with minor syntactic variations.

Dart provides a standard way to do inheritance which means that all libraries and frameworks will be able to inherit from each other.

Web Components and polymer is a good example of the power and re-use enabled by encapsulation. The http://www.polymer-project.org goal is that you can integrate and re-use Dart web components, Angular JS components, Firefox x-tags, etc within the same web app. Which is unprecedented in the fragmented world of JS.

> enterprises locked in a system

Why would anyone do that? We have a super nice solution for that. It's called "site-specific browser" or SSB.

It's like a browser without address bar, which automatically opens a specific URL on start up.

You can have one per intra-/extranet application and you can update them individually on a as-needed basis.

You get all of the benefits of a fixed platform without any of the downsides. Well, you'll need a little bit more RAM and and a little bit more HDD space, but that really shouldn't be an issue.

It is not the same I guess. Since there is dart2js, I think we can force a Dart application to run on DartVM when the browser is Chrome and run as js when it is not Chrome. I might be mistaken. You'll just see performance gain, the application is the same.

Dart has all the perils of an embrace and extinguish situation even if it is not the intention. Developers commit to Dart only to find in the future that the DartVM/Dart2JS targets have differing behaviour or levels of attention. And then suddenly Dart apps require Chrome and we end up with same IE6 mess again.

These situations can sometimes happen by accident or for technical reasons. And for me the web is far too important to take the risk.

Hi, I'm on the Dart team.

> Dart has all the perils of an embrace and extinguish situation even if it is not the intention.

I'm not sure what you mean by "perils" here, but if it's just "by deciding to use a product, you could end up following it in a bad direction if they do that", I'm not sure how that's different from any other product. Any technology can go in unpredicted directions.

> Developers commit to Dart only to find in the future that the DartVM/Dart2JS targets have differing behavior or levels of attention.

Historically, the dart2js team has had as many or more resources than the VM team. If you consider the past a predictor of the future, then this shouldn't be a concern.

> And then suddenly Dart apps require Chrome and we end up with same IE6 mess again.

That would be pretty crazy of us, though, right? We want our language to be successful. Intentionally making it only work on a minority of browsers (and the unbelievably massive negative political repercussions of doing that) wouldn't exactly do much for Dart's adoption.

I'm trying to imagine some nefarious scenario where that could happen, and I'm having trouble conjuring one up.

    Evil Chrome exec: Well done, minion! Dart is successful and has
      lots of users! Now is our chance to attack!

    Evil Dart exec: What have you in mind, O Master?

    Evil Chrome exec: Now we'll add a feature to Dart that only the
      VM supports. Users will have to use Chrome in order to run apps
      that use that feature! Mua-hahahaha!

    Evil Dart exec: But master, why would a developer use that feature
      if they know it will prevent millions of users from running their
      app?

    Evil Chrome exec: Uh... it will be such a delightful feature they
      won't be able to resist. Like... I don't know, currying or
      something.

    Evil Dart exec: But what happens if someone just sends us a patch
      to implement it dart2js too?

    Evil Chrome exec: Well, don't land it, obviously!

    Evil Dart exec: What should we say in the code review?

    Evil Chrome exec: Why do you bother me with these details? Just
      move ahead with our plan!

    Evil Dart exec: Remind me again what our plan is master?

    Evil Chrome exec: To force the world to use Chrome! Soon, we will
      be as successful as IE6 was!

    Evil Dart exec: Not to question your wisdom, master, but IE is no
      longer the dominant browser, so that didn't work out well for
      them, did it?

      Also, developers now universally revile IE because of their
      practices. We'd be shunned if we did something like that.

What about features like harmony proxies? I'd like to see someone transpiling that to ES5 and getting code that isn't super-slow.

Edit: Consider this dummy example:

  f(a, b) { return a + b; }

With operator overloading, the compiler has to account for that, and must transpile to e.g.

  function f(a, b) { return __invokePlus(a, b); }

Unless the programmer adds type hints

  f(num a, num b) { return a + b; }

Edit: mraleph told me that I'm incorrect - apparently the transpiler does global type inference on the code and will only generate a function call if the type needs it (or if it can't figure out the type)

> mraleph told me that I'm incorrect - apparently the transpiler does global type inference on the code and will only generate a function call if the type needs it (or if it can't figure out the type)

Exactly right. We need to do that, or numeric code would be impossibly slow when compiled to JS.

I wonder if this means Dart will be available in Opera, since it's based on Chromium now.

Does dart vm use type information to optimize? I can't find a good explanation. I'd really like to use static typing to gain both speed and early error checking.

If you mean type annotations then no, right now Dart VM does not use type annotations to optimize things.

Dart VM features an classical adaptive optimizations pipeline that first gathers type information from the run and then optimizes hot methods using collected type feedback to specialize the code.

For more implementation details about Dart VM optimizing compiler you can check out my talk from Strange Loop 2013 http://s3.mrale.ph/StrangeLoop2013.pdf

When will it switch from JIT to AOT? (SCNR)

Cool. Does this integrate with Visual Studio / ASP.NET MVC ? Otherwise this is a non-starter for me.

Typically, you would integrate it with ASP.NET the same way you do any other Single-Page App not written in JS or Typescript.

It ships with a dart2js compiler that you can use in VS. However, to really get the ease of development you're looking for you'd probably use VS to build/debug the backend, and additionally, the dart editor (special eclipse version) to debug the front-end. You'd have to enable your backend to support CORS calls for this type of setup. However, Once you are ready to deploy, the app builds to HTML/JS/CSS files that you can just embed normally in your solution.

I think what you're getting at is - is it better than JS or typescript + angular or backbone? It'd probably a matter of taste. The language is different from the "syntactic sugar" on top of JS that typescript is. Dart lets your bridge to standard JS libraries (i.e., Jquery etc), but, it also provides most of the functionality in the standard library. It provide a built-in unit test and logging framework and a nuget style repository of other libraries. Additionally, Dart's Polymer library provides an MVVM framework. You can define controls and combine into single-page webapps.

I can see Dart being big in enterprise, although with no support for IE7 and IE8 this could be an issue...

Not until there is a support across browsers and a must have framework that can only be used from Dart.

I still don't see any enterprise requests for CoffeScript, TypeScript or any other language that targets JavaScript.

When you work in teams, everyone across the company that needs to touch the source code needs to know the respective technologies.

There is cross support in the form of Dart2JS although that's IE9+

That is true, but then I'm not sure they offer as much as Dart does. (Plus I bet some MS shops use TypeScript).

You would think, but how many people developing Objective C know C well, it's more true in the beginning but as you go on the need to know about the target runtime diminishes. Do you know much about the JavaScript VM in the browser and how that compiles to C?

The point is what language the enterprise cogs need to learn and the supported browsers.

> Do you know much about the JavaScript VM in the browser and how that compiles to C?

Of course, if you want to write JIT friendly code you need to know the magic JavaScript incantation code patterns.

There is a reason why all browser vendors have developer sessions on their conferences about those patterns.

What about C to assembler?

Same thing. That is what -S in gcc is for.

Other compilers offer similar flags.

And before you ask, Assembly manuals explain how many cycles an opcode takes and what are the expected side effects on the chipsets.

The relevance of that is pretty insignificant unless you are building a framework or compiler. That's the point of abstraction.

Or if you don't care about performance.

> I still don't see any enterprise requests for CoffeScript, TypeScript or any other language that targets JavaScript.

GWT seems to have been widely used.

I meant browser side.

Plus GWT uses Java, a widely supported enterprise language.

GWT is browser side

Last time I used it (2011) the JavaScript was generated on the server side by a servlet. Has it changed?

The code runs client side.

Of course it runs on the client. Where else would the generated JavaScript from the Java annotations run?

Have you even worked in the enterprise ?

Because I have and continue to for the last 20 years and NOBODY is interested in a repeat of the IE6 fiasco.

Ha, I know a lot of big enterprise with Adobe Flash/Flex lockin, though that's slowly going away...

Yup that's where we are now, Flex is the only technology that can target IE7 and give us what we need.

We still have to support that far back, which has issues with a lot of frameworks and in this case Dart.

I don't think enterprise IT departments will ever subscribe to the always update nature of Chrome 1, so it just means more and more IE6 situations down the line.

1 We actually have an app that IT install that prevents you installing Chrome :p

I don't know...I work a lot in big enterprise stuff, and they've come around. One product we have that most banks use only runs in IE9+. That's really the min level now (or in the near future since our new version of the app isn't due until Feb)

I work on an FX trading application which has IE7 in the compatibility list :(

All other banks with similar apps have the same targets as far as I know. (HSBC, JPM, MS, RBS, Barclays etc)

> I can see Dart being big in enterprise, although with no support for IE7 and IE8 this could be an issue...

Actually it's not supported in any standards-compliant browser and only available in Google Chrome.

That makes it a bit of a no-no.

Dart runs in IE9 and up, Firefox, Opera, Safari, and Chome.

> Dart is new, yet familiar

Yes, but most people who write web apps don't like Java syntax. Publicising Dart without changing that won't stop the low adoption Dart's had for the last two years.

Edit: a reminder that that was the biggest piece of feedback from Dart announcement 776 days ago: https://news.ycombinator.com/x?fnid=oEG20axbbQ4CeS0NXvabbv

I can't think of any language other than Go that had relatively high adoption pre-1.0 . Of course I'm sure someone will point out a few examples... but I digress: Last I checked Java was the #1 or #2 top programming language in the world. Perhaps Dart makes it easier for a Java developer to do front-end web development while using a familiar paradigm.

Reports of Java's death has been greatly exaggerated ;-)My guess is, Java8 will solve a lot of the whining about boilerplate types. The closure syntax, is in someways, more economical than JS.

On the consumption side, yes. As far as I can tell, you still need to write out the function interfaces :(

But that's exactly the way library APIs should work, with all the pain and labor going into the API declaration, and the users of the library experiencing very little.

In type inferenced statically typed languages like ML, Scala, or Haskell, you can get away with not mentioning the types in the bodies of most functions. The type declarations at the library level serve as useful documentation.

That creates a somewhat artificial boundary between libraries and consumers.

I write plenty of code at all layers that would benefit from being able to accept code as an argument. If I want a private helper method that takes some code as an argument, do I have to create and name a function interface just for that?

Yes, Javascript's anonymous function syntax is needlessly verbose, but that's trivially fixed and will be in future versions. Changing Java to not need a function interface is a much bigger challenge that I'm willing to bet won't come about for a long time, and is going to be a source of frustration for lots of people as they realise how useful cheap anonymous functions can be.

I'd argue that there already is, in well written libraries, an artificial boundary. Library APIs often have to be written for the consumption of others, so more care is usually given (in well written) libraries.

You don't really need to create any function interfaces for most expressions since the most common ones are pre-defined (Supplier, Consumer, Predicate, Function, UnaryOp, BinaryOp, etc), and the basic rules allow a lot of flexibility.

I've been doing a lot of Java8 recently due to work integrating it into GWT (https://plus.google.com/+RayCromwell/posts/C4QYmWWQguT) and the experience has been delightful. In actual use (as opposed to testcases), it's been very economical, especially the this::foo constructor vs the JS equivalent which needs bind(), and the fact that you get good auto-complete is great.

My comment was poorly phrased regarding libraries. What I meant was there's plenty of code if want to use lambdas for that isn't a carefully planned api boundary.

Even with the provided function interfaces I worry there will be cases they don't cover which means people won't use anonymous functions where they're useful.

However, given you seem to have used Java 8 and. I haven't, I'll relent :)

I'm willing to be we'll still be talking about Java's impeding death in 10 years here on HN. With all the different languages supported on the JVM, and new ones to be invented....it's not going anywhere.

Or the fact it seems to be very prevalent in places like India and China.

The fact there is a new fashionable language in the valley doesn't mean it's going to be popular world wide.

Version numbers are arbitrary, and most of the JS community were quite ready to check out dart as soon as it was released.

Agreed re existing java developers though. But even in the java community, scala syntax is popular for the same radios dart is unpopular for web devs. I've seen more typescript interest than I have dart interest, again because type safety has nothing to do with unnecessary verbosity.

Languages have users just like programs do. We know, as developers, that making users do extra work is poor. Java is renowned as the 'I studied computer science at university but...' language. Why is Google unnecessarily repeating the mistakes?

Google: make dart 2 cleaner and you'll immediately engage not just java users, but existing web developers and people new to software as well.

> most of the JS community were quite ready to check out dart as soon as it was released.

There are definitely early adopter, bleeding edge types who love to look at things that are brand new. But we've gotten a lot of feedback from developers saying they are interested in Dart but not comfortable using it in mission-critical apps when the language is still changing.

Going 1.0 is a big deal for those people.

> I've seen more typescript interest than I have dart interest, again because type safety has nothing to do with unnecessary verbosity.

I'm not sure what you mean here. My experience has been that Dart is a good bit more terse than TypeScript (getting rid of "this." everywhere certainly helps). Are you trying to say Dart is unnecessarily verbose, or that that doesn't matter?

> Are you trying to say Dart is unnecessarily verbose

Yes. See other posts.

The only post I saw from you on that was main(). I'll reply there.

Please. Every professional developer (including Java focused one) knows enough Javascript to do what they need. Especially with frameworks like JQuery, AngularJS, KnockoutJS etc it all really isn't that hard.

And on large projects which are the domain of Java/.Net developers you often have dedicated Front End developers anyway.

People that write Java don't like JavaScipt, would be another way to look at it.

Working on large scale (tens of developers) web apps has serious issues with JS, and Dart can address some of that.

I don't expect to see AirB&B running via Dart, but Gmail, Google Docs etc will really benefit, and hopefully pave the way for some serious desktop caliber applications.

> People that write Java don't like JavaScipt, would be another way to look at it.

Not true, at least not in my case :)

There are webapps that use Java (or any JVM language) on the back-end and JavaScript on the front-end.

Check out Addy Osmani's "Making Maven Grunt": http://addyosmani.com/blog/making-maven-grunt/

> People that write Java don't like JavaScipt, would be another way to look at it.

Sure, but for different reasons: principally, lack of type safety. That's completely orthogonal to syntax.

Which Dart has. (Type safety)

Yep. I think everyone in the discussion likes (either optional or mandatory) type safety. That's why we want the syntax to be better. Type safety doesn't require semicolons, wrapper classes, wrapper functions, explicitly defining whether everything is public or private because there's no default, or lots of brackets.

Which Dart has. (lack of wrapper classes, wrapper functions, lots of brackets)

>> Type safety doesn't require semicolons, wrapper classes, wrapper functions, explicitly defining whether everything is public or private because there's no default, or lots of brackets.

> lack of wrapper classes, wrapper functions, lots of brackets

That's 3 items of 5. Of those 3:

- All the demos use wrapper classes and wrapper functions and I'm getting conflicted reports on whether Dart requires them or not (see munificent's post for example). If none of this junk is required, ditch it in the public docs.

- Not sure why you think Dart doesn't need brackets, it clearly uses them for blocks.

Not sure of your angle here, are you comparing to coffee script or something?

I thought you were referring to wrapping functions to return modules in JS. Or over use of anonymous functions that leads to confusing brackets and pyramids of curly brackets.

Comparing to most common web dev languages:

- Python, Ruby, Coffee don't require wrapper functions and classes for small examples, eg hello world or the Fibonacci example on dartlang.org. That said, another commenter mentioned the examples for Dart include these wrappers needlessly so this may be a documentation problem. - JS, Python, Coffee, Ruby and Scala drop semicolons to terminate statements (which users already mark with line terminators)

- Python and Coffee ditch the marking blocks with braces (which users already mark with indentation)

- Python, Scala, Ruby, and Coffeescript set either 'public' or 'private' as a default for new methods, so users don't have to specify unless they want the non-default behaviour.

(I have very little knowledge of PHP but from what I've seen it's generally not as chatty as Java either)

* Dart doesn't require "wrappers" or classes for anything, including hello world or Fibonacci. This has been pointed out in almost every comment where you've brought it up. Yes, the examples might be confusing here, and so for pointing that out thanks and I will bring it up with the team, but repeating the claim that Dart requires wrapper classes for functions is completely unnecessary at this point.

* Most of the popular languages use braces for blocks. I sort of like significant whitespace, but it brings a lot of other problems. In the end braces are a pragmatic choice and have very little bearing on the utility or usability of a language.

* Dart also has a default visibility: public. You change it to private by adding a leading underscore.

Yes, I've been quite happy to acknowledge the it may just be poor docs, as you'll have noticed. As the target audience for dart (I'm a web developer, who makes large apps, and doesn't already know dart) all I have to go on is the actual dart website, so you'll forgive me if I expect it's demonstrations would be showing the language as it's best.

Fix the docs, ditch the semicolons, and Dart may get more popular.

I think marking up blocks twice is a waste of time, and leads to the possibility of inconsistencies between indentation and parenthesis, but appreciate using indentation for blocks is too different for some existing programmers.

Reply on news.ycombinator.com