

Web-based editor for Kotlin, JetBrains' new JVM language - cgbystrom
http://kotlin-demo.jetbrains.com/

======
thebluesky
Looks like a mildly cleaned up Java, was expecting something a little more
interesting. Don't see much in the way of functional programming or worthwhile
changes vs Java.

Was expecting a Scala competitor, but found a slightly better Java with some
syntax sugar. It's "nice", but not really different enough to warrant the
effort of switching to another language. As a Java dev for 10+ years Scala was
an eye opener on what a language could really be, Kotlin is "nice", but sadly
not that interesting.

Minor pet peave is they have retained even Java's verbosity for outputting
text:

Kotlin: System.out?.println("Hi") Java: System.out.println("Hi") Scala:
println("Hi") Ruby: puts("Hi")

~~~
timclark
If it compiles faster than Scala I will use it!

From reading the language specs it seems much more pragmatic than Scala (as
does ceylon <http://www.ceylon-lang.org/> or fantom <http://fantom.org/>).

I think if JetBrains thought that Scala was a better Java they would be using
it instead of creating their own language.

~~~
verroq
It's unfortunate that Scala is fatally flawed because it was bound to the JVM.
Having java interop is both a blessing and a curse. The sheer scale of the
language implemented as a java library pretty crippled compile time.

~~~
guard-of-terra
Why do you link being based on JVM and long compile times?

Java is one of the fastest languages to compile (1000 files with ten megs
worth of code would take something under 10 seconds), while C++ and Haskell
are both very slow to compile even if they're not JVM based.

~~~
verroq
The specific way Scala is bound to the JVM (as a 8mb class library that needs
to be loaded every time) is the reason it is slow to compile and by
implication, slow-er startup.

I suppose we do need to take account of language features. C++ is a difficult
language to parse, and with a bit of template magic, and heavy compiler
optimizations that can be applied. Haskell has type inference and is
statically typed, that has to cost it some what.

Scala has a 8mb JVM library to load, and also type inference. It gets a double
whammy. However I'm willing to bet is the JVM is contributing a significant
portion of startup time, with both JVM startup time, loading java libraries,
then loading scala library. If the JVM wasn't part of the problem, then there
is no need for people to create tools like fsc to speed up compile time.

~~~
e-dragoev
Then just use fsc instead of scalac. It is part of the standard Scala
distribution. Last time I tried it - fsc was not that much slower than javac.

~~~
jsight
Yes, but is it faster than EJC? I'd bet that's the frame of reference for most
Java devs.

------
foobarbazetc
System.out?

Really?

~~~
thebluesky
That's exactly the type of verbosity in Java that new languages should avoid.
I'm a bit disappointed by Kotlin in general to be honest.

