Random Thoughts

Could Dart become the NB[J]VL (Next Big JVM Language)? Wait, did I just say JVM, Dart is a VM based language that could run on JVM as well (jdart), but could a language outside the JVM ecosystem beat the expectations of the NBJVL. In his blog entry, Stephen discusses what a new language should address to become the NBJVL. Just for those curious, Stephen concludes by saying that backward incompatible Java 8 could be the next best bet, which is unlikely to happen with major features already frozen for Java 8 and its release pushed to 2013, although reification is planned for Java 9, a long way to go indeed (2015?).

Does Dart fit the bill based on his definition of NBJL? Well, let us dig in further to see if Dart bites the bullet.

In terms of features, NBJL should probably have:

• C-like syntax (familiar and good-enough)
• Static typing (dynamic is too loose and ineffective for this type of language)
• OOP with functional elements (pure functional too hard for mainstream)
• Easy access reflection (to escape the static typing restrictions)
• Properties (because getters and setters are crazy)
• Closures (capturing looping design patterns)
• Null-handling (preferably a means to declare whether each variable can or cannot hold null)
• Concurrency story (something better than raw threads and shared mutable state)
• Modules (need to be thinking in terms of larger units)
• Tools (need a language to be designed to help tool writers)
• Extensibility (allowing some additions without going back to the language designer)

Let us discuss briefly on each of those features:

• Dart syntax is very familiar to C/C#/C++/Java developers and heavily borrows syntax from Java.
• Dynamically typed language. Supports Static typing in checked mode and type system can be completely ignored if need be.
• Supports first class functions with full closures.

• Reflection via mirrors is planned, but not yet available in Technology Preview.
• Properties are supported. The nice about this feature is if you reference properties directly and if you have getters/setters defined, it gets used.
• Supports function types.
• Null-handling planned.
• Single threaded and no-shared state. Concurrency is supported via Erlang-style actor based isolates.
• Supports the notion of libraries.
• Tools (DartC cross-compiler, snapshotting, eclipse IDE plugins, etc)
• There is no plan to support extension methods as in C# or Java 8, but looks like LINQ style functionality may be added later.

Looks like, Dart scores on most of these aspects. Dart is young, and many things would shape up in the coming months making it an even strong candidate.

Dart offers quite a number of interesting goodies which I consider as a bonus:

1. It is a pure OO language where everything is an object. There are “no” primitives unlike Java. int, double, bool etc are actually interfaces. Be sure to initialize numbers, because they are objects, their initial value is null, not 0.
2. There is no compilation step. Period. It just runs on the VM. Cross-compiles to different backends (Dart2JS).
3. Supports noSuchMethod() construct (similar to doesNotUnderstand in Smalltalk). Here is a dumb example, but you get the point how it could be useful in some scenarios, one shown in the Smalltalk demo. DartC does not implement this yet, so this code won’t work from Dartboard, but should work in standalone VM.
4. String/expression interpolation, multi-line Strings.
5. Reified generics.
6. Operator overloading.
I converted an existing C++ example from MSDN, which shows how similar the Dart code.
7. Factories.
8. Optional defaults. Default values have to be compile-time constants.

There are a number of nice little things, but I’ll leave them for another post.

When Dart was officially announced, it was mentioned:

The competition is NOT JavaScript

It lead to confusion in the developer community when Google launched a programming language for the web and stating that they are not competing with JavaScript. Since Dart caters to wide audience, the statement still holds true, because they compete on the server-side as well, not just client-side :-)

The USP for Dart is its unified programming approach on both tiers of application development. In my opinion, Dart is not just JavaScript done right, but it could very well become Java alternative on the server side. While, it is very early to judge how the language shapes up, but looks like Dart team (already 70 committers) is all ears for inputs and suggestions.

On the mobile front, Dart is going to make a huge difference atleast for Android. I believe it should be possible to produce Dalvik compatible .dex files using a backend similar to one which produces JS from the DART AST. Not sure how hard that would be. This would also mean generating Dart scripts from Java classes (java2dart).

Java developers for sure would feel home in Dart. Why would the NB[J]VL miss an opportunity to woo 10 million Java developers, leveraging familiar syntax? Food for thought :-)

In addition to traditional for loop (C++ style) and for-in loop (Java/C# style), Dart adds a convenient forEach method construct that takes a function and operates on the Collection. For example, using forEach() on a Map:

Using forEach() on a List/Set:

The only limitation with this approach is you won’t be able to break out of it. Dart doesn’t have non-local returns, so in that case you may want to use the for-in loop.

Another approach suggested in the dart user group is: