Hacker News Reader

Comment by higherpurpose | Hacker News Reader

A lot of Android developers don't like Java because of its syntax. Dart seems very similar in syntax to Java (which I assume was intentional, but the wrong thing to do)...so not much improvement there. No wonder Dart hasn't been getting anywhere near the excitement Go has received.

What Android needs isn't just a slightly better Java that isn't owned by Oracle, but something more like Python that has the performance of C++, for the next generation of developers. If they're going to deprecate Java in Android and cause everyone a lot of grief over it anyway, they might as well do it right, and for something truly exciting to make people rally around it.

View on HN

Actually I think Dart has a lot of benefits in terms of syntax compared to Java. I am working with java since 2001, so I can tell. If you are interested to briefly look at it, you can do that here: https://www.dartlang.org/docs/synonyms/

Dart makes me excited, when i am honest :-)

Well, comparing with Java is aiming a bit low, isn't it?

Compare Dart's "shorter alternative" of a bog-standard class ...

  // Shorter alternative
  class Person {
    String name;

    // parameters prefixed by 'this.' will assign to
    // instance variables automatically
    Person(this.name);
  }

... with something more modern:

  class Person(val name: String) // Done.

Maybe I am old-fashioned, but declaration of member variables in like in the second example makes me afraid. :-) Whats that for a language btw?

Scala.

C# 6 also copied it (although it doesn't really look that clean, because of their incompatible mess in fields vs. methods vs. properties).

Scala did never grew in me. But I heard its getting better once you made the first few weeks.

Yes. It's probably the same weird confusion I had, too ... because all "experts on the Internet" complain about Scala being a kitchen-sink of features, but if you actually walk into it, you just wonder how they managed to reduce and condense features into such a small, well-designed orthogonal core ... and wonder why no one else did it before.

In hindsight, Scala is much smaller than C#, F#, C++, OCaml, etc. while still being more expressive and comfortable to use.

Let's remove the comments for a more visually fair comparison:

  class Person {
    String name;
    Person(this.name);
  }

  class Person(val name: String)

Ok, you save a line. I don't think that's a big deal. Also, the Dart version is very clear about what's a field or not. The first example I found of Scala classes on their site is this:

  class Point(xc: Int, yc: Int) {
    var x: Int = xc
    var y: Int = yc
    def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
    }
    override def toString(): String = "(" + x + ", " + y + ")";
  }

With text that says `x` and `y` are the fields. What about `xc` and `yc`, I thought those were the fields?

Another thing I like about Dart is that the possible variations on the constructors fall into place, consistently:

No constructor args:

  class Person {
    String name;
  }

Optional constructor args:

  class Person {
    String name;
    Person({this.name});
  }

Super call:

  class Person extends Animal {
    String name;
    Person(this.name) : super() ;
  }

The short Scala form may do that as well for all I know,

> Let's remove the comments for a more visually fair comparison:

It was not meant to be unfair, I just took an existing example. If the Dart devs thought they needed the comments to make it clear what happens, then it's a decision I respect.

> Ok, you save a line.

Three.

> With text that says `x` and `y` are the fields. What about `xc` and `yc`, I thought those were the fields?

For standard classes, the compiler just does what you tell him:

If you write that you want a "val", you get an instance value, if you write a "var", you get an instance variable, if you write nothing (like in this case), you will usually get ... nothing.

That's perfectly clear in my book.

> Another thing I like about Dart is that the possible variations on the constructors fall into place, consistently:

In most languages, allowing a constructor which forgets to initialize things is considered a compiler/language bug.

(And having more than one constructor is pretty much considered to be an anti-pattern in Scala anyway.)

> Super call:

In Scala:

  class Person(val name: String) extends Animal

Reply on news.ycombinator.com