Dart (originally Dash)

Performance – Dash is designed with performance characteristics in mind, so that it is possible to create VMs that do not have the performance problems that all EcmaScript VMs must have.

Developer Usability – Dash is designed to keep the dynamic, easy-to-get-started, no-compile nature of Javascript that has made the web platform the clear winner for hobbyist developers.

Ability to be Tooled – Dash is designed to be more easily tooled (e.g. with optional types) for large-scale projects that require code-comprehension features such as refactoring and finding callsites. Dash, however, does not require tooling to be effective--small-scale developers may still be satisfied with a text editor.

There will be several ways of running Dart:

Dedicated VM: as a substitute for JavaScript, in all browsers.

Server: with the goal to enable “Google-scale” web applications where front end and back end are written in the same programming language.

Cross-compiler: that compiles Dart to ECMAScript 3 on the fly, for compatibility with non-Dart browsers. Compare to Google Traceur [2] which compiles ECMAScript.next [1] to ECMAScript 3, in a similar manner.

The FAQ at the end of the email makes it clear that Google intends to use Dart wherever it can (at least in the web space). It also makes it clear that Google expects the migration from JavaScript to Dart to take a while. There will be a tool to help with the migration:

The Dash Cross Compiler should be capable of taking typed Closure code (with some restrictions) and converting to Dash. Although the migration process won’t be fully automatic, it should make moving over to a Dash codebase somewhat easier.

Hidden in the FAQ: Google is working on a “cloud IDE (Brightly)”.

Brightly will enable building any web application in V1 using today’s
Javascript plus the additions in Harmony. As soon as it is ready, Brightly
will support Dash as well. We expect that the more prescriptive development
aspects of Brightly that will come on line in the future will be more Dash
focused.

We expect Brightly itself to be the first application written in Dash.

What does it all mean?

Consequences for ECMAScript.next [1]. Just as ECMAScript is making tremendous progress, Google decides to throw their weight behind a completely new programming language. I wouldn’t mind that if Google’s strategy really was two-pronged, if they gave the same consideration to JavaScript:

Keep the ECMAScript.next-to-JavaScript compiler Traceur up to date.

Create an IDE that is as good at ECMAScript.next as it is at Dart.

Mainly the latter does not seem likely. I also hope that Google does not put the main focus of its ECMAScript work on features that help with compiling Dart to it. The email sounds like it, Alex Russell does not. Contrast that with Microsoft’s approach of writing several core Windows 8 apps in standard HTML5 [5].

Will it be technically sound? The three goals for Dart are spot-on. I love that they are focusing on toolability, an area in which JavaScript currently has severe deficiencies, especially compared to Java. The goal of “developer usability” ensures that the language will remain lightweight. There are brilliant people working on it – that have both compiler expertise and language design expertise:

For example: Gilad Bracha has great taste in language design, his work on Newspeak and pluggable type systems [PDF] is exemplary. Newspeak is currently the best guess for what Dart will look like – given that both of the presenters at the GOTO conference have worked on Strongtalk. Strongtalk is a language that added an optional static type system to Smalltalk, a dynamically typed language. This approach would go together well with the Dart goal of “developer usability”. Newspeak is in many ways an evolution of the Strongtalk ideas. Furthermore, an IDE has always been at the core of Newspeak’s design which jibes with the “ability to be tooled” of Dart.

Is Dart really open? Let’s first recap how uniquely open JavaScript really is – there is no other programming language that is as open:

With ES-262 (ECMAScript), JavaScript has a very precise, easy-to-read specification. Doing such a specification well is much work, but it is essential for ensuring that all JavaScript engines remain compatible. Ironically, back in the day when Netscape had a browser monopoly and Microsoft had to catch up, Microsoft pushed for this kind of standardization to initially happen. All major browser vendors and the public collaborate to evolve ECMAScript. However, the core group working on the design is relatively small, works together well, and prototypes most of the proposals. That avoids many “design by committee” problems.

There are several competing implementations. That might sound like a disadvantage, but it isn’t: It leads to a robustness of the JavaScript ecosystem and pushes innovation. For example, Firefox borrowed ideas from Google’s V8 to make their JavaScript faster.

In contrast, Dart is almost proprietary: It is not developed in the open and only shown to the public once it is finished (Brendan Eich calls this “delayed-open”). Plus, all of the developers work for Google. It’s great that it is free and eventually open source, both of which will help its popularity. But it probably will never be nearly as open as JavaScript – Google does not have a good track record when it comes to writing specifications for things it open-sources. A recently leaked Android email reminds us that Google is not always as innocent about openness as they sound. Quoting it verbatim:

Do not develop in the open. Instead, make source code available after innovation is complete

Lead device concept: Give early access to the software to partners who build and distribute devices to our specification (ie, Motorola and Verizon). They get a non-contractual time to market advantage and in return they align to our standard.

Will other browser vendors adopt it? If you are a competing browser vendor, your prospects for adopting Dart are as follows:

It is difficult to integrate into your existing infrastructure (as you couldn’t give early feedback).

Its development is mainly controlled by Google.

You give Google a head start of over two years.

That’s not very appealing. With that background, Google’s plan for involving other browser vendors sounds naive:

What if other browsers don’t follow us with Dash?

Lars has promised to “sweet talk” the other browser vendors and, while we are all eager to see this, we recognize this is a very difficult road. Our approach is to make an absolutely fantastic VM/Language and development environment and build great apps that fully leverage it in order to help other browsers see the wisdom in following. Once Dash has had a chance to prove its stability and feasibility, we are committed to making Dash an open standard with involvement from the broader web community.

It is not a good sign that Brendan Eich, a guy who really works his behind off to involve the community in the design of ECMAScript.next has not been approached, yet. He should be the first person for Google to target with their “sweet-talking”. Oh, and how is that for sweet-talking [emphasis is mine]:

Why are you circumventing the standards process?

We fully intend to cooperate fully with standards processes--the problem is that the current standard processes are limited to Javascript, which is not viable in the long term. Any effort with the historic baggage that Javascript has will be extremely limited. We need to make a clean break, make progress, and then engage the community.

That is an incredibly simplistic statement. How can they possibly predict what JavaScript will look like in the long term – a language that is currently very minimal and thus easily extended? The above statement would also sound better if Google mentioned their own motivations, something along the lines of “we want to try something different and to (initially) go it alone”.

Isn’t Dart similar to CoffeeScript? Yes and no. To run either Dart or CoffeeScript [3] on a JavaScript engine, you will have to perform a translation step. However, CoffeeScript intentionally stays close to JavaScript semantics which means that it is a transpiler (only local transformations), while Dart will probably need a compiler (that makes sophisticated non-local transformations). Source-code-level debugging is in store for CoffeeScript [4], but it’ll be much harder to implement for Dart. Thus, Google Chrome with a dedicated Dart VM will probably be the best way to run Dart for a long time and that could considerably fragment the open web.

Why not just standardize a universal virtual machine and compile both JavaScript and Dart to it?
Brendan Eich has talked about this. Byte codes are always tightly coupled with the language they support, so finding an approach that everyone is happy with is practically impossible. Intellectual property rights are another challenge. Years ago, the Java Virtual Machine had the potential to become the “web virtual machine”. But things went differently and Sun ignored the client-side of the web while Ajax took off. Source code is the byte code of JavaScript, possibly with more compact syntax representations in the future. It seems weird, but it works surprisingly well.

Other voices on Dart

Here is something that the Google leak about Dart (née Dash) telegraphs: many Googlers, especially V8 principals, do not like JS and don’t believe it can evolve “in time” (whatever that might mean — and Google of course influences JS’s evolution directly, so they can put a finger on the scale here).

They’re wrong, and I’m glad that at least some of the folks at Google working in TC39 actually believe in JS — specifically its ability to evolve soon enough and well enough to enable both more predictable performance and programming in the large.

There’s a better-is-better bias among Googlers, but the Web is a brutal, shortest-path, Worse-is-Better evolving system.

I’ve spent the last 16 years betting on the Web. Evolving systems can face collapses, die-offs, exigent circumstances. I don’t see JS under imminent threat of death due to such factors, though. Ironic that Google would put a death mark on it.

On Dart: Google as a single entity does not know what could be done in Ecma TC39, since the Dart/V8 principals never participated, and V8 needed a fresh-thinking second team finally to get going on Harmony prototyping.
...
Innovating in the open and proposing early and often to standards bodies are fine. Delayed-open-washing and increasing piles of proprietary (open-source doesn't matter) single-vendor code, which implements features that are not ever proposed for standardization, are not.

For the record, I'm not worried about JS being replaced by a better language. I am working to do that within Ecma TC39, by evolving JS aggressively.

The leaked Google doc's assertion that this is impossible and that a "clean break" is required to make significant improvements is nonsense, a thin rationale for going it alone rather than cooperating fully.
...
Dart is GBScript to NaCl/Pepper's ActiveG.

Look, Netscape had a monopoly and put JS "on first" and just about everywhere. I'm done apologizing for that, I've made up for it in spades on standards work, and it's a fact I cannot recall and rewrite.

The precise point now, here on planet earth and not wherever you are, is that Google is not that new monopoly. Not yet, not likely for years even in their wildest dreams.

If Google were the monopoly Netscape was, sure: Dart would be the new JS. The two would co-exist for a long while but "replacement" would be conceivable so long as market power held up.

Since Google does not have monopoly power, and with the non-standardizing tactics of that leaked memo, Dart is unlikely to be adopted by other browsers. It's fragmenting. It's an invitation to others to inject their own would-be replacements and build a Tower of Babel.