Dart is ready for the real world

Why are we bothering with developing new languages when what we should be doing is developing a web standard for a universal bytecode + VM? Hell, use the JVM or the CLR, just as long as it doesn't tie me to a specific language. Dart may be better than JavaScript (I would hope so) but that doesn't mean it's a silver bullet. If we create a standardized bytecode, it doesn't matter what language produced it.

I've been thinking about something like this for a long time. However, the question came up in an interview or presentation with either Brendan Eich or Douglas Crockford (I can't remember exactly where I read this) about why Javascript won out over a VM solution (supposedly this is what the JVM was made for). The most salient argument against a universal VM was that maintaining backwards compatibility between byte-code versions and the competing eco-system of languages would have been a nightmare. Instead the web targeted a single language (and all the trouble that has been along with it). I would rather like to see other languages on the web but I don't think a browser is good place to do it.

Instead what I'd rather see is http://www.cs.cornell.edu/home/ulfar/cuba/paper/ -- work could be done to improve that initial design, but the idea IMO is that the OS already handles processes and allocating memory well and the browser vendors are terrible at this task by comparison.

Either way, Dart is an interesting experiment and I'd give it a shot on some prototyping projects.

Yes, this may look a bit weird, but it actually makes perfect sense. Those types are annotations. If you use them at the "API boundaries" (parameters and return values), you already get most of the benefits you may know from Java or C#.

Compare the doc comments you usually have to write with those baked-in type annotations:

    /**
     * Foos the bar.
     * @param {int} x
     * @param {int} y
     * @returns {String}
     */
    function foo (x, y) {
        ...
    }

    /// Foos the bar.
    String foo (int x, int y) {
        ...
    }

Additionally, adding those type annotations is useful right off the bat. The IDE will make use of them right away.

>Go on the other hand [...]

Well, Go is very different. It has a completely different focus. It's more like Rust, for example.

Thanks to "tree shaking" (=dead code removal), you'll reach the break-even point fairly quickly though. You can use massive libraries, buy only those pieces you actually use get included in the final output.

For example, the last JS app I wrote is about 80kB (minified and compressed). jQuery alone took about 33kB of that. How much of jQuery do I actually use? I'd guess it's less than 20%.

So, even with that initial overhead, a Dart version would be probably a bit smaller.

http://channel9.msdn.com/Shows/Going+Deep/Anders-Hejlsberg-a...