
Kotlin M7 - danieldk
http://blog.jetbrains.com/kotlin/2014/03/m7-release-available/?utm_source=twitterfeed&utm_medium=twitter&utm_campaign=Feed%3A+kotlin+%28Project+Kotlin%29
======
programminggeek
Kotlin for a lot of reasons is the most interesting language to me right now.
Go doesn't have immutability and doesn't seem to care so much about functional
programming. It's great, but not what I want. Scala seems like a big language
that tries to do a lot of things and thus it has a very slow compiler and a
slow turnaround time for changes.

What Kotlin seems to be getting right so far is the useful side of functional
programming features, IDE support, and a reasonably fast compiler. Compiler
speed is something that Kotlin actually cares about, which last time I played
with Scala, it was still dog slow to compile or even wait for it to decide to
compile after you make a change.

Developer experience is very important to me and for the kind of software I
want to build and the way I want to build it, Kotlin looks very promising.

~~~
programminggeek
Sounds like I need to give Scala another shot if compile times are a lot
better.

~~~
lanna
A very useful tip: instead of invoking sbt on the command line (i.e, 'sbt
compile') every time, first open the sbt shell (just type 'sbt') and from
there you run 'compile', or better yet '~compile'. This way you will always
have a warm jvm. Makes a lot of difference.

------
neilellis
I've written a fair bit in Kotlin of late and I've got to say it's a great and
pragmatic language. The writers have done a fantastic job - please don't
underestimate how hard it is to write a language never mind a very good one.

I would recommend all Java developers to give it a try, especially if you use
Intellij.

I'd like to counter the childlike moaning about Java being old and creaky and
dated - JavaScript has been around since 1995 and was pretty much a laughing
stock 10 years. Things change.

Clothes go in and out of fashion - so it seems do languages.

JavaScript has changed minimally since 1995 - but the changes that we've seen
have been important. If V8 hadn't been written I'm not sure JavaScript would
have had this resurgence. I also wouldn't advise anyone to assume big changes
are needed to make Java more modern. The right small changes are enough (e.g.
objects to C, or lambdas to Java) - I suggest that Kotlin (and very possibly
Ceylon) have made the right small changes.

Right, off to write some COBOL Server Pages now ...

------
hamidpalo
My biggest hope for Google IO '14 is the announcement of Kotlin as the Android
language. Yes, you can already use Kotlin for Android actually but it's not
well-supported and the community is small.

The benefit for Google and developers would be clear -- no more Java and
Oracle shenanigans. Google already has a solid relationship with JetBrains due
to the fact that Android Studio is just IntelliJ CE. They could hammer out
details about who owns it, what the future looks like, etc. The transition
would be easy since Kotlin already plays well with Java.

JetBrains would have a massive win as well since it would drive sales of
IntelliJ like no other.

~~~
pjmlp
Or Dart. That is the only way I see Dart getting any real traction on the IT
world at large.

But I agree with you given the move to Android Studio, Kotlin would be a
possible candidate as well.

~~~
munificent
I spent a few minutes searching GitHub for the number of repos in different
languages. The query I came up with is:

    
    
        https://github.com/search?q=stars%3A0..10000&type=Repositories&ref=advsearch&l=<lang>
    

Where <lang> is replaced with the language you're curious about. Here's a few:

    
    
        Kotlin    200
        Dart    2,836
        Erlang  9,087
        Groovy 11,515
        Go     24,603
        Scala  25,846
    

While we've still got lots of catching up to do, I think Dart is doing pretty
well given its youth. (I would include TypeScript in the above but
unfortunately the language detection for it is broken so it reports a bunch of
Qt C++ projects as TypeScript).

~~~
vorg
For comparison...

Top 10 languages:

    
    
        JavaScript  648,839
        Ruby        512,620
        Java        464,330
        Python      323,857
        PHP         319,106
        C           169,390
        C++         165,497
        CSS         141,254 //not Turing complete, but oh well
        C#          111,748
        Objective-C 107,682
    

JVM languages:

    
    
        Scala       25,854
        Clojure     17,532
        Groovy      11,520 //seems to be mostly picking up lone Gradle build scripts
        Kotlin         200
        Ceylon          60
    

Also:

    
    
        Typescript   3,042 //search function only intermittently fails
        Dart         2,888
    

Big business language:

    
    
        Cobol           50

~~~
diroussel
According to who?

~~~
vorg
See the parent comment I replied to for the link, a language comparison of
Github projects.

------
peeters
The inlining feature is great, if for no other reason than shooting down
stuck-in-the-past devs that say "yeah but all those function calls are so
_expensive_ ".

~~~
pcwalton
In my experience, at least for static languages, inline annotations are very
useful in the hands of a skilled programmer; the compiler's inline heuristics
are always static guesses at dynamic properties and as a result they fall down
from time to time. (The JVM may be able to do better here though—it has the
ability to inline functions at runtime via a recompile if they discover that
they're being called a lot.)

------
netcraft
I'm really rooting for kotlin - it seems like a good runner up to scala
without the poor compile times. Looking forward to a 1.0 release

~~~
gecko
Kotlin's brilliance is how much _less_ it's trying to do. It's truly narrowly
focused on fixing what's broken in Java—not introducing an entirely new
language that happens to compile to the JVM. That'll make adopting it in
organizations much easier, converting code to it much easier, and so on.

That said, I never figured out why Xtend
([http://www.eclipse.org/xtend/](http://www.eclipse.org/xtend/)) never caught
on, and it delivered most of what Kotlin is now offering, but with an even
more Java-like syntax right out-of-the-box. Since Kotlin and Xtend are very,
very similar, I suspect that Kotlin's ability to genuinely succeed will be
mostly based on JetBrains' popularity how strongly they push it.

~~~
thescrewdriver
> I never figured out why Xtend
> ([http://www.eclipse.org/xtend/](http://www.eclipse.org/xtend/)) never
> caught on....

> ... with an even more Java-like syntax

I think you have your answer right there.

The other reason is that nobody likes the idea of having a language which
compiles to Java source code.

~~~
gecko
People have no real problem with languages that compile to C or JavaScript, so
I'm not really convinced that's the problem as such. The lack of source
maps/#line pragmas in Java didn't help, I'm sure, but these are solvable
problems if there's interest (as demonstrated by #line and source maps).

------
thescrewdriver
Looks decent, but I find it difficult to get excited about. Perhaps I'm not
the target audience since I'm very comfortable with Scala (and love what
Jetbrains is doing with the Scala IntelliJ plugin).

~~~
frowaway001
Agree. I'm always amazed by people who say "Kotlin is great because it doesn't
try to do more than fix a few warts of Java!", ... did these people ever leave
their Java bubble?

The world is moving on at a frightening speed when it comes to language design
currently, largely thanks to Idris. The idea that some people think "hey,
let's pick this language from 1995 and change it slightly" is going to cut it
... that's just mind-boggling.

~~~
pron
I find it completely reasonable, and the right course of action.

All those new ideas in language design, are exactly that: new and unproven
(like the Hindley-Milner type system, which, while quite old already, has not
been proven to be a major strength, and it is certainly complicated, esp. its
undecipherable error messages).

"Languages from 1995" (I don't know why you picked that specific year; some
very successful languages are much, much older) have been used to build really
good software, while "new" languages (Heskell, 1990; OCaml, 1996; Scala, 2003)
have not proven to completely change software quality in a way just justifies
their arguably less intuitive (if only culturally) designs.

Where are all the bug-free Haskell operating systems, drivers and embedded
controllers? Where are the OCaml scalable severs? Where are all the Scala
complex enterprise apps? I'm not saying there isn't any really good software
written in those languages, but not nearly enough to prove a significant
qualitative advantage.

On the other hand, when Java came out in 1995, it took maybe 5 years for
pretty much the entire software world to adopt it, and it wasn't just
marketing: its advantages were palpable and immediately apparent. I think
(though I'm not sure), that C and later C++'s adoption was about as fast. If
25 year old languages like Haskell, and even 10 year-old languages like Scala,
haven't shown such an immediate and enthusiastic widespread adoption, maybe
their advantages aren't that extreme. Instead of those languages' designers
sitting mind-boggled, maybe they should think long and hard about what it is
that they're solving exactly and how important it really is.

I think the problems tackled by more "modern" languages are either not
important enough, or their solution is far from optimal. For example, it is
quite possible that a good type system could help produce good software faster
(though it isn't certain either), but that this type system is Hindley-Milner
seems unlikely at this point. Pluggable type systems (like the ones recently
introduced to that 1995 language, and, I believe, also supported by Kotlin)
might actually be a better way to go forward. I also think that some more
important advances in programming languages have come not from PL researchers,
but from developers (Java, Erlang, Clojure).

~~~
agumonkey
> If 25 year old languages like Haskell, and even 10 year-old languages like
> Scala, haven't shown such an immediate and enthusiastic widespread adoption,
> maybe their advantages aren't that extreme.

Haskell advantages are so extreme they elude most.

What were Java first 5 years advantages ? Wasn't it all 'Java is client-side
silver bullet' ?

ps: by Pluggable Types did you mean Type Annotation
[http://openjdk.java.net/projects/type-
annotations/‎](http://openjdk.java.net/projects/type-annotations/‎) or just
the Checker Framework ?
[http://types.cs.washington.edu/jsr308/‎](http://types.cs.washington.edu/jsr308/‎)

~~~
pron
Type annotations are the frontend to the pluggable type systems provided by
Checker (but they were added to Java 8 in order to support Checker):

[http://docs.oracle.com/javase/tutorial/java/annotations/type...](http://docs.oracle.com/javase/tutorial/java/annotations/type_annotations.html)

EDIT: I think Java's initial advantages were taking good C++ concepts,
simplifying them, and running in a safe environment (GC memory, app can't just
crash etc.).

~~~
agumonkey
That amounts to Guy Steele quote about moving halfway to Lisp. Haskell is on
that same road, just way further.

------
midas007
Does anyone know of a specific production use-case where coding for eager
evaluation (Idris, OCaml) is more straightforward and predictable when lazy
evaluation could be cheaper on computing resources (Haskell)? When does lazy
evaluation become too nondetermistic or painful that eager becomes more
reliable? (Scala could probably go in either bucket.)

~~~
mercurial
Well, I'd say most of the time... Where I find laziness (or "laziness
implemented via iterators") worthwhile is when working with collections. But I
much prefer the bits that care about such thing to explicitly return an
iterator, the bits which don't to be able to operate either on iterators or
concrete collections, and me to have a better idea of how much space and time
will be consumed.

------
midas007
Kotlin homepage: [http://kotlin.jetbrains.org/](http://kotlin.jetbrains.org/)

------
Flow
I fail to see what it offers over Ceylon. [http://ceylon-
lang.org](http://ceylon-lang.org) For the past two years I feel that Kotlin
has gotten more hype than work put in it.

~~~
pron
I think the main difference is that Kotlin fully embraces the current Java
ecosystem, and makes integration with it seamless, while Ceylon rejects it and
seeks to replace it with something new. Personally, I prefer Kotlin's gradual
approach to Ceylon's revolutionary one.

------
puppetmaster3
Kotlin, lets bring back the good old times. It's a step back, lets me explain:
Like Scala, it's strongly(stringly) typed, needs IOC to get to work.

Modern langs used like node.js, rails, django, go, grovy are all dynamic.

~~~
puppetmaster3
You downvote that? that's rich.

