Google Dart – overview and comments

Today, it has finally happened: At the GOTO conference, Google has officially presented its new programming language, Dart.
This post gives an overview of Dart and provides a few comments on how it fits into the current programming language landscape.

Information on Dart

Dart in a nutshell

Currently, Dart is not a JavaScript replacement, but rather a “better Java” plus a next-generation GWT.

The language is less like JavaScript and more like an improved version of Java: reified generics, first-class functions, optional types (no type errors, just warnings), getters and setters, no primitive types.

Interfaces

Factory classes for interfaces. An interface can specify a factory class which can be considered its default implementation. You can now directly instantiate the interface, its constructors delegate to the constructors of the factory class. If you use normal constructors then that is not much different from a normal class (but you don’t get the multiple inheritance of interfaces). Things become interesting with factory constructors, because you can create your own instance (including an instance of a subclass). I’ve seen interfaces being abused in Java code, to the point where there wasn’t a single class that didn’t implement an interface, so we’ll see where this goes. This feature does not provide mixin functionality. That is, if you implement an interface, you don’t get default method implementations via the factory class.

Dart code is always single threaded. There is no shared-state concurrency in Dart. Concurrency is supported via actor-like entities called isolates.
An isolate is a unit of concurrency. It has its own memory and its own thread of control. Isolates communicate by message passing. No state is ever shared between isolates. Isolates are created by spawning.

Miscellaneous features

There is a standard library with collection classes (List, Set, Queue, Map, etc.) and a DOM API.

Equality is handled via the == operator and delegates to the Comparable interface (for non-null values).

You cannot access JavaScript directly from Dart. In the future, there might be a way to run JavaScript code in an isolate and communicate with it via message passing. In GWT, integrating native JavaScript is easy. Whether that ease will ever come to Dart will depend on how Google eventually positions it – as a JavaScript replacement or as a Java/GWT replacement.

How does Dart fit into the current programming language landscape?

If you like Java and can’t get yourself to like JavaScript, you program Dart.

If you like Ruby and can’t get yourself to like JavaScript, you program CoffeeScript.

If you like JavaScript, you program JavaScript.

What do you get compared to Java?

Currently, Dart is almost like GWT (which is not a bad thing): Running “natively” on a virtual machine on the server, compiled to JavaScript on the client.

Basing the Dart IDE on Eclipse makes sense, because you get a lot of functionality (such as Git support) for free and because it is familiar to Java programmers.

Dart seems like an upgrade of Java, like a cleaned up version. It even carries over some negative Java-isms, such as fields automatically becoming part of the local scope.

What do you get compared to JavaScript?

Main Dart killer features: optional types, actor-like concurrency via isolates. However, you can do a lot via type inference in JavaScript, class literals will come to ECMAScript.next [2] and web workers are becoming more sophisticated all the time. Dart foregoes some of JavaScript’s quirks, but then again, so does ECMAScript.next.

In many ways, Dart feels less versatile than JavaScript. For example, JavaScript object literals are a very powerful feature. Dart is more static and only has classes.

Dart seems to have decent tooling, but it’s based on Eclipse. In contrast, many JavaScript IDEs that are currently in development are based on web technologies. Writing an IDE for a language in the language itself has many advantages.

At the moment, Dart isn’t even faster than JavaScript on V8. Presumably, that will change in the future. But this goes to show how fast JavaScript has become and that it didn’t need static types to get there.

Not a JavaScript replacement? Quote from the talk:

We are not targeting JavaScript, but rather fragmented mobile platforms.

I’m not sure what that means. Will Dart target these platforms by compiling to JavaScript or by compiling to the native mobile environments? It almost makes you wonder whether Google really knows what to do with Dart.

Google could have gotten the same results by supporting ECMAScript.next [2] (plus possibly some advanced, not yet standardized features) and Traceur [3].

As things are now, we have a clean but fairly simple language without any stand-out features. For example, not even multiple inheritance via something like traits is supported. Dart’s syntax is of the familiar but generic C-style variety (Java, JavaScript, C#). As long as Chrome does not come with a built-in Dart VM, Dart feels more like a Java replacement and a next-generation GWT. Maybe it should stay that way and Google should use native Dart on servers and Android (to avoid copyright troubles) and continue to always compile it to JavaScript on web browsers. That would prevent an unpleasant fragmentation in client-side native languages.

Tentative pointers in that direction are Google not yet committing to integrating the Dart VM into Chrome and saying that Dart doesn’t target JavaScript, but a “fragmented mobile platform”. That is a marked change in tone from the openly anti-JavaScript document that was published last year [1]. And it is also a very weak message about what Dart actually is. Google will have to eventually give clear answers. By missing the opportunity to do so during today’s event, they have weakened the impact of the launch.

If you want to see a truly innovative language, take a look at Newspeak: Its elegant syntax has the well-known Smalltalk advantages and there are fresh new ideas regarding modularity and IDEs (check out the paper on Hopscotch). Gilad Bracha, one of its creators, is part of the Dart team, which is why I expected more from that language.