Slashdot Mirror

HAR! its a new programming language (2011) https://kotlinlang.org/ [kotlinlang.org] So there aren't too many with 10 years experience....

Whooosh!

What's Kotlin? (Feminine hygiene? Geeks should'nt name products...)

HAR! its a new programming language (2011) https://kotlinlang.org/ So there aren't too many with 10 years experience....

I have far more than 10 years experience bullshiting experience I don't have. I first coded *, 12 years before it was specified.

That's what they're asking for when they ask for that. It's simply code for 'must be willing to sling bullshit'.

If you have to do it, learn from it. Not just technical, bullshit skills are lifelong useful. Who knows? You might end up a consultant.

Well, my boss, when he had the chance to meet people before they dealt with me, would always tell them "Just remember, don't bullshit a bulshitter." So I guess I qualify. 8^)

Personally, I think Java is the way to go until we invent another language which is clearly better and can easily and automatically be converted to from Java.

Or you can just use Kotlin: modern syntax, lightweight (uses the JVM libs instead of inventing their own), pragmatic mix of procedural and functional, excellent interop with compiled Java, production ready (created and used by JetBrains for tools like their Idea IDE).

Or Scala - same advantages you quote for Kotlin, but more widely available, and it's central to tools like Apache Spark.

Personally, I think Java is the way to go until we invent another language which is clearly better and can easily and automatically be converted to from Java.

Or you can just use Kotlin: modern syntax, lightweight (uses the JVM libs instead of inventing their own), pragmatic mix of procedural and functional, excellent interop with compiled Java, production ready (created and used by JetBrains for tools like their Idea IDE).

Kotlin

All the new JVM based languages that are popping up are just syntactic sugar on top of Java. The real concepts can't be shaken, as the JVM is pretty much limited in what it can do and what it can't.

Telling from the examples, Kotlin seems to be a good example: Yet another poor copy of Java with some "obsolete" things like the semicolon removed (why is there so much hate for it?), and you write "fun" instead of "function". So what. I don't think this makes me more productive than Java. Its just for all the people who keep preaching "java is shit" because they've heard it somewhere and now they want to use a "much better" language.

If Kotlin suits, Java is fine for the job as well, and most likely its even better.

If you're developing for Android it is worth checking out Kotlin along with the Anko libs from Jetbrains.

Kotlin, by the company that provides the Android Studio platform, is built on the Java platform and adds a modern, fashionable multi-paradigm (OO, functional) syntax, fixes some gaps in the Java standard libs, adds optionals that are (IMHO) easier to read than Swift's. It seems to be the best bet for getting a modern, fashionable language on Android, ie does not add to download size, seamless operation with other libs, etc.

You can also use Kotlin as a backend language, eg with Spring Boot, and it compiles to JavaScript too, so can be used client-side. You could even use it on iOS if you wanted, with RoboVM.

I've spent the last few years developing focusing almost 100% on iOS, but am willing to give Android another try in 2016

.

Oops, I forgot something important.

There is a simple web based IDE that you can use to experiment and learn the language at try.kotlinlang.org. For me it seems there's a layout issue with Chrome right now, but it works fine in Safari.

Is Swift suitable for writing applications for all? If not, developers would be writing for a limited, albeit popular platform, but limited to a certain subset nonetheless.

No, it's Apple specific. However that's OK because there's a language which is much like Swift, except it runs on pretty much every device you might have.

That language is new. It's called Kotlin, and it is from JetBrains, the makers of the highly popular IntelliJ series of IDEs (+ WebStorm, PHPStorm, RubyMine, PyCharm etc).

Kotlin targets the JVM and JavaScript. It interops perfectly with Java. That means code written in it runs on Windows, Mac, Linux and Android. Additionally, via the RoboVM project, JVM bytecode can be compiled to native ARM iOS/OSX binaries. There is no JIT compiler. RoboVM provides bindings to all Objective-C APIs on iOS so you can build native UIs and access all the same functionality as a native app. Programs written this way are on the app store, so Apple is cool with the technique.

Kotlin has a clean, concise syntax and many modern features that match those in Swift. For example it has nullability/optionality integrated with the type system. It has Markdown comments. It has extension functions. It has some support for pattern matching. It has named parameters. It has the ability to define "data classes" that have easy immutability, content equality, hashcodes, serialization etc all in a single line of code. It has type inference and compile-time inlined lambdas, so you can do high performance functional programming with it. It has features to support complex DSLs. It has a full IDE with many built in refactorings, online static analysis, and via the JVM it has high quality CPU/memory profilers and debugging support.

In short, programming with Kotlin is much like programming with Swift, except you have better tools, an IDE at least as strong as Xcode and in my experience stronger, and you can write apps with it that are indistinguishable from native iOS and Android apps.

Java is ugly. It is not complex by any reasonable definition, unless you're comparing it to BASIC or something. Part of the reason Java is ugly is that it's so simple, in fact - it eschews syntax sugar and various conveniences that'd make the code shorter and prettier.

I tend to feel that Java is on the wrong side of programming language trends here: there's a lot to be said for simplicity, but some languages are showing that you can add a lot of convenient and helpful features to Java-like languages without exploding the language's complexity budget. C# for instance is widely agreed to be more pleasant to use than Java (at least, widely agreed by most devs with experience in both that I've met).

On the JVM unfortunately we've been kind of limited until now in the "simple, beautiful yet performant" space. There are languages like Scala that are static enough to be reasonably fast, but there seems to be a growing consensus that Scala is very complicated. I've seen it be called the C++ of the JVM. There are lots of dynamic languages like Ruby, Python, Groovy, Clojure etc that gain simplicity and terseness by abandoning static typing entirely but sacrifice maintainability and performance. There's Frege, a Haskell dialect that I have no experience of, but lazyness-by-default seems a controversial choice at best.

Lately there's also Ceylon and Kotlin, which seem to be exploring a new space in PL design that can be summed up as Scala but made a lot simpler. The syntaxes are terse and compact, the typing is static, the IDE support is developed alongside the language, and they compile to both the JVM and Javascript. Kotlin is my personal favourite. The feature set eliminates much of the tedious boilerplate in Java without adding much potential for code maintenance disasters or excessive complexity. It also increases safety, like by making nullability a part of the type system.

Nim looks syntactically a little bit like Kotlin, which compiles to either JVM bytecode or JavaScript. If you compile to the JVM then you can not only use libraries written in Java, but also JavaScript, Python 2.x (via Jython), Ruby, Scala, C (via JNA), there's even a Haskell for the JVM called Frege.

Interesting.
Unfortunately, many Python packages use compiled C code (Cython etc.) which only work in CPython, i.e. not in Jython, not even in PyPy. The most important such difficult-to-port package is NumPy.

If I were to create a new language, I would not focus on creating the most beautiful syntax or the best built-in functionality. Instead, I would make damn sure it plays well with other languages and that it is trivial to use software packages already written.

Nim looks syntactically a little bit like Kotlin, which compiles to either JVM bytecode or JavaScript. If you compile to the JVM then you can not only use libraries written in Java, but also JavaScript, Python 2.x (via Jython), Ruby, Scala, C (via JNA), there's even a Haskell for the JVM called Frege.

The really neat trick, though, is that despite looking not much like Java at all, it compiles down to code that is binary compatible with Java and there is a Java-to-Kotlin rewriting tool, meaning you can convert existing Java codebases one file at a time whilst still having a fully compilable project. Thus you can not only leverage existing codebases written in many languages, but also slowly convert legacy codebases too.

Kotlin has some syntactic features that look similar to nim, like if being an expression not a statement, ranges, type inference, compile time inlining control, operator overloading, generics etc. Kotlin also has a a variety of features that focus on creating DSLs, but doesn't do it using a full blown macro system.

Nim has some things Kotlin doesn't and vice versa. I can write a more complete comparison (based on reading the docs) if anyone is interested. But the reason I mention it, is Kotlin's focus on interop with existing code.

Plus other bits of code actually required to make it run.

They also say that they think the same findings would hold for C++. So whilst it's a bit hard to know if this technique is useful without reading and pondering the paper, it isn't saying much about Java specifically.

That said - we all know Java is a very simple and verbose language. That has some advantages like ultra-fast compiles, but lots of disadvantages too. So here I'm gonna point out Kotlin, which is a new JVM language with transparent Java interop (in both directions). It's a lot more concise and expressive than Java, whilst simultaneously having a stricter type system. The neat thing about Kotlin is, it's developed by JetBrains so you get completely seamless integration with their refactoring IDE. Also there is a Java-to-Kotlin converter feature that lets you turn a Java file into a Kotlin file instantly, and you can convert a codebase on a class-by-class basis. So you can start using the features of the new language right away. Also, it runs on Java 6, so it's Android compatible.