Kotlin: A statically-typed language that compiles to JVM bytecode and JavaScript

http://kotlin.jetbrains.org/

by shawndumas • 13 years ago

85 93 13 years ago

kotlin.jetbrains.org

curtis• 13 years ago

I am happy to see that there's some example code on the home page.

desireco42• 13 years ago

I am honestly a little tired of one more language that is statically typed and compiles in js. It really has to bring something huge for me to consider it, even from name like JetBrains.

jonsterling5• 13 years ago

I am pretty tired of statically typed direct-to-JS languages which are wildly unsound. I use TypeScript at work, and I grant it's hugely safer than JavaScript and has saved us from dozens of defects even in the two weeks since I introduced it, but its type system is pretty broken.

A DSL written in a dependently-typed language (such as Idris) would suffice for both the kind of safety and the level of expressivity I require. (Unfortunately, the various JS backends for Haskell, Idris, Agda, etc. are not usable for my purpose, since I need the output to be readable and debuggable).

Anything less than what I have proposed in the previous paragraph is pretty uninteresting to me. It's unfortunate that people are working so hard on Kotlin, when it cannot contribute anything new or interesting, by its very nature.

profquail• 13 years ago

Have you looked at Haxe (http://haxe.org/)? It's supposed to have a decent type system, although I can't say how it compares to TypeScript's since I've used neither of them.

If you need a stronger type system, and you're already using TypeScript, take a look at FunScript (http://funscript.info/); it uses the meta-programming features of F# to do strongly-typed JS (and TypeScript) code generation and interop with existing code.

mortyseinfeld2• 13 years ago

It's unfortunate that people are working so hard on Kotlin, when it cannot contribute anything new or interesting, by its very nature.

Maybe you can think outside of yourself for once and consider that your uses cases or personal preferences aren't what the Kotlin devs consider important.

camus25• 13 years ago

but its type system is pretty broken.

In order to have a type system that is compatible with javascript , there are things you just cant do. I think Microsoft TS team did an acceptable compromise. TS is not perfect , but the fact that one can still use pure JS in typescript is a huge plus.

michielvoo• 13 years ago

but its type system is pretty broken

Can you explain this? Thanks!

jshen• 13 years ago

It has the few things that I believe will make my life a lot easier.

1) compiles to jvm and javascript 2) handles null better than java/javascript 3) good tooling

I don't know of many other languages that hit this mark.

hhariri7• 13 years ago

Kotlin targets the JVM and JS. Emphasis on targeting both, not just one.

Targeting to JS allows for certain scenarios, such as those I recently wrote about: http://blog.jetbrains.com/kotlin/2013/10/writing-kotlin-in-t...

laureny4• 13 years ago

Probably the most promising language on the JVM in my opinion, one that stands a reasonable chance to see wider adoption than the faltering and overly complex Scala.

Kotlin feels like an incremental improvement over Java that I can wrap my head around and it comes with stellar IDE support right out of the box.

I hope they release a 1.0 soon so we can see if it gains traction, but it will be challenging, because Java certainly seems invincible right now, and probably for years to come thanks to the imminent Java 8.

pron10• 13 years ago

I absolutely agree. I can see my future projects being written either entirely in Kotlin or in a combination of Kotlin and Clojure.

Kotlin is a very practical, well thought-out language, that was designed with the right approach re language features: if in doubt, leave it out. The result is simple, modern and powerful, with – and this one is extremely important – top notch Java integration. It is extremely easy to integrate Java and Kotlin in the same project, and easy enough to go back to Java if Kotlin doesn't catch on. Kotlin is very easy for Java developers to learn, and easy to read and understand if they haven't learned it. It feels very unobtrusive when introduced into a Java project.

qwerta2• 13 years ago

one that stands a reasonable chance to see wider adoption t

Not just compared to Scala but any other language. I actually think Kotlin is more similar to Groovy than Scala. Sure the facade is veri similar, but the philosophy and internals are very different. Also founders of Groovy and Groovy++ (statically typed) are involved in Kotlin development.

Most of Scala was created by postdoc and students. Kotlin was created by java company who want to scratch their own itch.

I especially like that Kotlin is 100% compatible with Java. I think best trick in language design is how Kotlin interacts and adds new features into legacy Java codebase. For example it introduces 'immutable collections' into existing Java Collection hierarchy without modifications.

seanmcdirmid2• 13 years ago

Most of Scala was created by postdoc and students. Kotlin was created by java company who want to scratch their own itch.

Even though the students and postdocs definitely contributed, it is still probably accurate to say most of Scala was created by Martin Odersky.

ebiester• 13 years ago

I've heard that from a few people, but nobody is willing to stick their neck on the line and actually try it for a project.

And is Kara better than (for example) Grails? Are we going to be stuck writing Spring MVC?

hhariri7• 13 years ago

Maybe it doesn't count, but at JetBrains we're using it both internally and in a successful product such as WebStorm and IntelliJ. LiveEdit is in fact written in Kotlin.

Also, I've written Wasabi (Sinatra/Express like framework) and am using it on a project.

http://github.com/hhariri/wasabi

I also know of quite a few people using it already.

pron10• 13 years ago

I'm going to use Kotlin in a project as soon as it reaches 1.0.

camus25• 13 years ago

Saying that scala is complex is like saying lisp is complex just because you cant read it.

Scala has very little syntactic rules. Of course if you dont take the time to learn them , you are not going to understand the language.

laureny4• 13 years ago

Scala has very little syntactic rules

There are a lot of counter examples to this claim but just to keep this short, I'll go along with your claim.

A downside of this is heavy overload of keywords/symbols. For example, last time I checked, the underscore (_) has six different meanings depending on where it's used.

The number of syntactic rules is not a good way to judge whether a language is difficult to read, otherwise, Brainfuck would be the most readable language on the planet.

pron10• 13 years ago

No it isn't. Scala has three complete type systems: an OO, inheritance based type system, a Haskell-like algebraic type system (sealed traits and case classes), and a duck-typed type system (structural types). Each of these type systems has been enough to write good, complex software on its own (in different languages, of course). Scala's got all three, plus macros. Scala is a superset of Java, Haskell, JavaScript and Lisp; such a language is not simple. A language where it takes an expert to understand how the standard library's linked list is implemented is not simple (even the language creators say that understanding, let alone implementing, Scala collection classes is reserved for experts). You may well understand parts of it, most of it or even all of it given enough time, but it is definitely not simple.

EDIT: Scala does have an incredible compiler, though, and it is interesting from a PL research POV (which is to be expected, given its origins). The JVM community will forever be indebted to Scala. But it is not a language that many will feel comfortable using, and most of those that do, use a subset of it (which is basically Kotlin), and ignore the fact that they can't understand how the linked list is implemented. Kotlin takes a lot of inspiration from Scala, obviously, and learns from its mistakes. It takes that subset of Scala that gives people 99.9% of what they want and need with only 10% of the complexity.

konstruktor3• 13 years ago

This reminds me of one of my favourite Stackoverflow threads, where Odersky himself explains in just a few paragraphs why the signature of the map function in Scala is not overly complicated: http://stackoverflow.com/questions/1722726/is-the-scala-2-8-... I am not joking when I say that they have actually introduced "simplified signatures" into the API docs after this :)

So yeah, if it takes several paragraphs to explain why something that can be as straightforward as this (Haskell)

(a -> b) -> [a] -> [b]

is actually not that complicated when it looks like this

def map[B, That](f: (A) ⇒ B)(implicit bf: CanBuildFrom[List[A], B, That]): That

it is clearly the stupid infidels that don't get it. This doesn't mean that Scala is a bad language in general, just that it is ridiculous to state that it isn't complex, especially compared to Lisp.

riffraff• 13 years ago

Scala has very little syntactic rules.

Are you sure this is true? Compared to what?

trurl3• 13 years ago

Without any kind of support for algebraic datatypes or case classes it isn't viable replacement for Scala.

tootie• 13 years ago

Lack of support for algebraic data types sunk my last project said no one ever.

konstruktor3• 13 years ago

It is what I have been waiting for for years: A C# for the JVM, i.e. a very expressive language with a well thought out type system that allows using some functional idioms.

kenbot4• 13 years ago

How is Scala faltering?

niutech• 13 years ago

It's old news - see https://news.ycombinator.com/item?id=2784086

dgreensp2• 13 years ago

Does anyone know how Kotlin bridges the differences between the JVM and JS?

For example, the demo video that prints an ArrayList of Integers raises more questions than it answers, given that JavaScript doesn't have Integers or ArrayLists and has different built-in stringification (which is always idiosyncratic from language to language). Can I write portable code that uses arrays?

Some quick poking around indicates that Kotlin is pretty JVM-centric for someone who works in the web world. (I used to write a lot of Java and Scala and even wrote a mini JVM once, but these days JavaScript is my go-to platform.) There's good old byte/short/int/long and there's boxing of primitives. They don't even bother to mention that arrays have immutable size (like Java and unlike JS), presumably because they assume it's obvious.

Inexplicably, the English words "and" and "or" are used for bitwise operations while && and || are unchanged. Hate to criticize but it all just seems rather strange.

hhariri7• 13 years ago

The demo (I'm the author of the video) is showing JVM, not JavaScript target.

For JavaScript, check out:

http://blog.jetbrains.com/kotlin/2013/10/writing-kotlin-in-t...

camus25• 13 years ago

First thanks for your excellent products. JetBrains rocks and i bought 2 ides from your business.

Now my question :

Why didnt you chose an existing language like Dart for instance?which would have been closer to java and still compile down to javascript. I think dart on the jvm would be a great idea.

dgreensp2• 13 years ago

Great, I have an expert here! So how does Kotlin bridge the differences between Java and JS? Can I write portable code that manipulates arrays? Does Kotlin use JavaScript's number semantics when it targets JavaScript, or does it emulate Java's?

I'm starting to suspect Kotlin is a unified syntax but doesn't actually have any unified semantics, or considers all heap objects to be "foreign" and owned by either Java or JS.

I was expecting to hear one of a few reasonable approaches to making code portable across Java and JS. For example, Kotlin has its own concept of an array which happens be backed by an ArrayList in Java land. Or, classes like ArrayList are emulated in JS by a runtime library.

eonil• 13 years ago

I like to know whether this language support these stuffs.

- C++ level of const correctness or a simple way to make immutable data structure. Or immutable view of full data structure.

- Explicit symmetric coroutine with safe data sharing machinery. I mean something like Erlang process or Goroutine.

- Any meta-programming facility such as macro or template.

hhariri7• 13 years ago

1. Yes 2. No 3. A bit. Not macros or templates but nonetheless you can do some type of meta programming with reflection.

mwcampbell• 13 years ago

Do you plan to add macros or some other kind of compile-time metaprogramming? I think it's important to have that, since reflection is at odds with obfuscation and also introduces runtime overhead compared to compile-time code generation.

rnikander2• 13 years ago

[...] the faltering and overly complex Scala

I use it everyday for work, and it's an excellent language. I think it "falters" because it's more ambitious than anything else. Kotlin doesn't look as ambitious so far. I'd rather stick with Scala and see them keep improving. There are some promising ideas in the pipeline for future simplification without loss of power: http://www.infoq.com/presentations/data-types-issues

lmm9• 13 years ago

If that's the one I think it is it, the proposal would make type-level programming much harder to debug than it currently is (because it becomes impossible to specify the types of type-level functions).

rnikander2• 13 years ago

I don't know what you mean here. I'd be curious to see an example.

woutervdb2• 13 years ago

Another day, another new programming language that compiles to [popular language]. I'm sorry, I may be looking at this from the wrong perspective, but in my opinion, they're starting to lose their value. Sure, accessing a hard language (like C, or Python (for me, I find Python difficult at times) by writing your own dialect or higher-level language can be fun and maybe can make your workflow better, for me it doesn't.

Actually, I view these higher-level languages as the program that ships with a Raspbery Pi (don't know what it's called, sorry), which uses a drag and drop interface to create loops and create a game. You'll learn the basics of programming, but having a company where everyone speaks their own higher-level language won't really work. You're especially fked if you've got a developer that has to read the generated code, in a lot of cases.

Please correct me if I'm wrong, I'm still genuinely interested in the purpose of such languages!

hhariri7• 13 years ago

Not exactly sure what you're saying here.

woutervdb2• 13 years ago

English is not my native language and I'm kinda busy, so it's pretty hard for me to explain myself, sorry.

I'm saying that languages like these (if I understand correctly), when compiled, result in a program generated by said language, "written" in another language, like Javascript, Java, Python or something.

Personally, I see no value in doing so. It creates a bit of an "overhead" (you compile it twice), and you actually don't really see what happens in the layer below the layer you're working in: the JS/Java/Python layer.

Say you've been working in the language FooBar, which creates, say, Javascript. Now most examples of code generators I've seen don't really care about the readability of the code they output. They have a readable, human-created bootstrap.js loading the default handler, and a bunch of semi-obfuscated .js floating around.

Usually, this doesn't matter. However, I see a lot of these languages appear on HN lately. The problem I'm starting to see is that, when we've got 10,000 alternatives to FooBar, people all start using different FooBar-like languages, and it becomes a mess. If you, for example, like to write in BarFoo, then we have a problem. We both understand JS, but the generated code is a mess. What do?

Then again I could be wrong. :P

shock• 13 years ago

I think Scratch[1] is the name of the programming language that you're referring to, that comes with the Raspberry Pi.

[1] https://en.wikipedia.org/wiki/Scratch_%28programming_languag...

deathanatos• 13 years ago

This has null-safety. As in, you can't assign null to a variable without explicitly qualifying that variable as "nullable". Glad to see this.

But it's yet another language with strings-are-a-list-of-code-units. I've mentioned it before, but I'd like more languages to follow Haskell/Python's suite of "String are a list of code points", at the very least. (Those as others have point out, while dealing with code points is less error prone than code units, you probably want something even higher level.)

Integers are still range-limited. For some things this is okay, for some things it'd be nice to not worry about what happens when you get near 4B. Python solved this nicely. (There's a place for range-limited ints, and you can always have a ranged_int<0, 65565> type, or something. But by default, I don't want to think about overflow!)

Generics appear to be C#/Java like (i.e., limited, not full meta-programming).

Some things that run when targets to the JVM don't in JS. `for(c in "a string")` didn't compile for JS, nor did `1000000000000000 or 0`. (To be sure, this isn't exactly easy.)

(Last, the issue tracker infinite-redirects, likely because it doesn't handle a browser rejecting cookies.)

DigitalJack2• 13 years ago

Could you take a crack at explaining code-unit vs code-point? I'd never heard of them, and they sort of looked like the same thing on Wikipedia.

aardvark179• 13 years ago

A code unit is the minimal bit length for a character in a particular encoding, so in UTF16 that's 16 bits and in UTF8 it's 8 bits.

A code point is a character, that may be encoded by a single code unit or may require multiple code units.

Mostly Java handles strings as 16bit code units, code point functions were only introduced at 1.5.

bjeanes• 13 years ago

Is this JetBrains' answer to Eclipse's Xtend (http://www.eclipse.org/xtend/)?

colig• 13 years ago

I started using Kotlin on the weekend and I have been pretty happy with it. The only issues I have with it so far is that I would like to use a package name with more than two identifiers (eg. com.android.scripting, instead of just com.android), and there isn't a succinct way of declaring multidimensional arrays. I resort to doing something like

        val arr: Array<Array<Tile>> = Array<Array<Tile>>(height, { x ->
            Array<Tile>(width, { y -> Tile(x, y, Terrain.GRASS) })
        })

Now I'm looking at writing my array in Java instead and making good use of Kotlin's interoperability with Java. :)

udalov• 13 years ago

Most of the time you can omit type arguments:

        val arr = Array(height) { x -> Array(width) { y -> Tile(x, y, Terrain.GRASS) } }

Kotlin: A statically-typed language that compiles to JVM bytecode and JavaScript

Related Stories