[bitL]

Not sure why Kotlin would be picking this fight - Python and to some extent R already dominate in data science with a little bit of Scala added in Spark - where does author see an opening for Kotlin? For high performance libraries nobody would pick Python or any JVM-based language either, and that's what most of the wrappers end up calling anyway (C++, CUDA, Fortran, OpenCL).

[SmirkingRevenge]

Python is often a second class citizen in these areas, even if much is made about its widespread support in the data science realm. I don't want to say it's hype is overblown... but a lot of the pain points and cracks in the seams are glossed over.

Take spark, for instance. You run into extreme performance issues the second your data has to be serialized to cross the py4j gap. An many essential parts of its API require scala/java (presumably Kotlin ought to work as well).

Similar situations occur all across the big data and cloud realm, with python. And then even still today.. you'll run into situations where whizzbang data science ml library that solves your exact problem.. for some reason is python 2.7 only. Thankfully that situation is getting rarer (there really isn't an excuse for it today) - but its still there.

In any case, a "not-java" language that can talk java is freakin amazing, in my book (Scala doesn't scratch my itch there - it's far too clever - had enough of that with perl back in the day).

[lmm]

Scala is a lot simpler than Kotlin once you get into the details - it uses a few simple but very general features rather than a lot of ad-hoc language-level functionality. A lot of the time what looks like some complex construct in Scala is actually two or three separate features combining in a way that makes perfect sense once you look at the pieces, and you can click through to see how the thing is implemented in plain Scala. (Indeed I'd say Kotlin is far more perl-like - its design deliberately emphasises immediate developer convenience at the expense of having a coherent underlying model)

[aninhumer]

I think saying something it's simple because it's based on simple rules can be slightly misleading. This is why I like to distinguish the ideas of "complication" and "complexity".

To me "complicated" means that the rules of a system require a lot of information to describe, i.e. it has a lot of special cases and caveats to learn. Whereas "complex" is more about the variety of emergent patterns in a system which are necessary to understand it and interact with it effectively.

As an example, rules of Go are very simple, but we probably wouldn't call it a simple game. In contrast, the rules of Chess are rather more involved, with quite a few special cases. Both games can be called "complex", but I'd also say that Chess is more complicated.

So using these terms, it sounds like you're saying Scala is less complicated than Kotlin, whereas the parent is perhaps saying that Kotlin is less complex?

[SmirkingRevenge]

Interesting perspective, thanks. I'm not proficient with scala, and most of my attempts to learn more of it were to be able to read some bit of code in a tool or library that was giving me trouble. So... grains of salt and a that.

That being said, having gone through at least one book, and have read lots of code - I still find it very difficult to parse in my brain.

It feels more complex to me, because there seems like there are so many implicit things going on, where something like Kotlin makes efforts to be explicit (yet still strikes a nice level of conciseness). But that could also be my inexperience with scala.

[lmm]

Definitely read using an IDE rather than a text editor if you weren't already. Scala is the first language I've seen to really make intelligent use of the GUI - not in a dragging-boxes-and-arrows way, but with implicits that are visible subtly (green underline, expandable by mousing over) but not there by default. The way I see it, it's a novel middle ground for things that you don't want to be completely invisible, but don't want taking up a lot of space either, e.g. error handling (exceptions are completely invisible, go-style explicit error handling is too verbose) or access to mutable state, or async operations, or... (the for/yield sugar is similar, with a lightweight "<-"/"=" distinction between effectful operations and not, and then you mouseover to see what the specific effect is). Working with inferred types is also easier when you can mouseover or hit a hotkey to get the type of any expression.

Having different syntax for different kinds of effect as Kotlin does could be seen as more explicit I guess, but I find it actually makes it harder to work with - you have a lot more syntax to keep in your head, and you can't write generic code that works with multiple different effects. Other than that I don't think there's anything more explicit in Kotlin, and some things - error handling in particular - are definitely less explicit.

[fulafel]

> In any case, a "not-java" language that can talk java is freakin amazing, in my book (Scala doesn't scratch my itch there - it's far too clever - had enough of that with perl back in the day).

Clojure is a bunch simpler than Scala, many Python programmers are quick to pick it up. The dynamic nature and interactive prompt is all there.

If you look at Norvig's Python-Lisp comparison table at http://norvig.com/python-lisp.html - all the red cells (where Lisp lost to Python) are fixed in Clojure.

[SmirkingRevenge]

I agree. I really like clojure a lot (though have only toyed with it.. and years ago at that). I think I would like to see it gain more adoption.

[earenndil]

> In any case, a "not-java" language that can talk java is freakin amazing

I don't understand why this is such a big draw for people when literally any jvm language[1] has this feature. Languages like jython, ABCL, clojure, jruby, groovy, and perl6. Kotlin is certainly not unique in this regard.

1: https://en.wikipedia.org/wiki/List_of_JVM_languages

[SmirkingRevenge]

True. But I think Kotlin strikes a nice balance of seamless interoperability, convenience, and apparently few compromises. The java interop feels natural - far more natural than it does in most of those other languages you mention (I don't have experience with them all though) - but the language is more concise and convenient than java, even though its very similar. It also has static typing.

Some of the languages you mention come with serious compromises when used on the JVM, like Jython and Jruby - decent portions of their ecosystems are implemented in C - and hence won't work on the JVM.

[SmirkingRevenge]

Not sure what the downvote is for....

It's notable that projects like spark could have used Jython for its JVM/python interop, but chose py4j instead, consigning pyspark to some rather abysmal performance penalties under many conditions.

[earenndil]

> Not sure what the downvote is for....

I'm not sure either. Your comment seems perfectly legitemate to me...

[deepsun]

I love Python, but after working on a large Python project I saw first-hand that JVM scales way better to large codebases.

Currently Python took a niche between quick ad-hoc exploration tasks (land of R) and production pipelines (land of JVM/C#/C++), but for large pipelines it's not so suitable IMO.

[blt]

I use Python for machine learning, but I wish I could use a friendly, modern, statically-typed language like Kotlin, Swift, etc. instead. Dynamically typed languages feel scary beyond around 1000 lines of code.

[XorNot]

Python 3.6's optional types are pretty great. Block out your solution first then start constraining it where you need to.

[icebraining]

+1, I recently wrote some data extraction and processing code using pandas and mypy, and it was pretty great. And progress is happening to add types to numpy and pandas themselves.

[riku_iki]

You still have many not type annotated libraries in ecosystem, and poor support of refactoring/navigation in IDEs.

[terminalcommand]

The downside is that static typing makes your programs much more rigid. Even if you program to interfaces, apply open-closed principle etc. After a while you start fighting the type system.

That's why I like dynamic typing. Coupled with Python's type annotations for hard cases and good documentation, dynamic typing allows you to go further by reducing cognitive load.

[taeric]

That there are dominant players in a field shouldn't preclude someone from trying. Especially if you see a face that could use help. Safety would be a good candidate here.

[shoo]

If you want to integrate MIP / LP as one component of a larger production system, and you are already using kotlin / JVM ecosystem, then this could be an advantage.

[pjmlp]

IBM and NVidia do have CUDA JVM support.

There are .NET CUDA implementations as well.

[bitL]

It's always like that; JVM is just way behind the cutting edge and people have to wait years to get access to latest stuff. I quit that a few years ago, now I go straight to the source, unhindered by whatever *VM is out there, even if it means learning new things every single day.

[pjmlp]

That is common to any language that isn't part of the OS vendors stack, not only Java.

For example, on Android, Java is the name of the game, beyond 3D rendering and audio codecs, the NDK is quite useless as everything else is exposed behind JNI calls.

[agibsonccc]

Cuda4j is only implemented in the ibm jvm and last I saw was slow to add newer cuda versions.

[pjmlp]

Still, it is a possibility.