
How fast are JVM-based languages growing among developers? - MarinaSprava
http://blog.jelastic.com/2012/05/14/how-fast-are-jvm-based-languages-growing-among-developers/
======
bad_user
It's interesting that JRuby has the lowest popularity in this pool, being
included as a " _honorable mention_ ".

If I were to take a guess, that's because JRuby is used by many Ruby
developers that want to use the JVM and its associated libraries and it is
maybe used less by Java developers.

Maybe that's because JRuby tries to be a Ruby VM first and a JVM language
second. The difference is subtle, however it leads to important differences.
For instance the preferred way of doing package management is to use RubyGems
and Bundler, instead of Maven and its repositories or something based on it
(compared to SBT or Gradle or leiningen). And devs when working with JRuby are
using the same libraries as they use with Ruby MRI, because many libraries
provide a JRuby-optimized backend. For example devs working with JRuby would
rather use Nokogiri, which is used for searching XML/HTML docs with XPath/CSS3
selectors, instead of something Java-specific.

So JRuby's ecosystem is more closely tied to Ruby MRI, rather than to that of
the JVM, which is why I think this article is not really accurate and JRuby
shouldn't really be on that fourth place.

And out of these alternative languages, I love JRuby more because this is a
language with multiple mature implementations, which isn't something many
languages can brag about, and I don't have to be tied to the JVM and its
ecosystem.

------
llambda
As anecdotal/non-scientific polling and researching, this is certainly
interesting. Perhaps the big take away for me is the OP's note that the JVM
rather than CLR has become a big target for emergent languages where a few
years ago CLR was billed as the future of cross platform endeavors. (Note that
at least one of the Big Three, Clojure, now also targets CLR in a branched
project.)

Slightly disappointing is the fact that while Clojure scores highly among
developers it doesn't seem to have made a proportionally large impact on the
commercial space. However it's important to note that the OP only draws these
conclusions from one source, Indeed.com, and I have to wonder how
representative this is of the kinds of companies that might be hiring for
Clojure related jobs: in other words, would they be on Indeed.com's radar at
all?

Finally, can we really draw any significant conclusions from these non-
scientific points? Probably not, but it is interesting to wonder: there seems
to be a good deal of momentum behind the JVM at this point and it will be an
interesting, exciting future if Groovy/Scala/Clojure become leading languages.
(Even more interesting is the prospect that they might all end up being
leading languages...)

~~~
Dn_Ab
Very interesting languages are being built for both the CLR and JVM. On the
JVM the main ones I know of are Scala, Clojure and Kotlin. I think
ClojureScript deserves mention even if a dialect due to the thoughts it allows
one to think more easily (LightTable).

The CLR also has lots of very interesting languages under development.
Languages like F# and Nemerle. Microsoft Research also pump out cutting edge
stuff like the dependently typed F* (<http://research.microsoft.com/en-
us/projects/fstar/>) and in language support for probabilistic programming
<http://research.microsoft.com/en-us/projects/fun/>. The problem with MSR
stuff is that their licences are so cumbersome and restrictive.

~~~
ConstantineXVI
ClojureScript doesn't run on either the CLR or JVM; the compiler is JVM-based
Clojure but the output runs as JS. And it's worth noting that Scala, Clojure,
and Kotlin all originated outside of Sun; where F# originated from inside
Microsoft.

~~~
Dn_Ab
Yes, that's why I made a note of its dialect nature. But I still count it as
something that sprung from interesting work in the JVM community that deserves
to be noticed on its own. In this case, the output as javascript is almost
incidental, the more interesting results is the language-browser interaction
it allows.

It does not matter where the research got done as long as it's interesting and
moves things forward. Anyways, the cultures of MS and MSR are so different, it
is arguable if one can even consider MSR as part of Microsoft. Sort of like
Hong Kong and China. MSR fund a lot of haskell work for example.

------
diminish
Hey everyone, we considered Clojure and JRuby for developing an open source
web framework but gave up at some point due to Oracle's aggressive Java
monetization crusade, currently against Google. Sun was a reliable partner for
open source community but doesn't Oracle make you afraid while you develop
anything java or jvm-related? Could you give us some rationale, why Oracle
won't chase your future project or what you must do in order to be immune
against being an aggressive target for Oracle, especially if your project
grows to be noticeable?

~~~
trimbo
> Sun was a reliable partner for open source community but doesn't Oracle make
> you afraid while you develop anything java or jvm-related?

The suit is regarding an implementation of Java that did not pay for a license
(Oracle's claim, not mine) -- not applications built on the JVM or Java.

So I'm curious, what can they do that you fear? They give away the JDK/JRE for
free. Ungodly mountains of code are developed on top of this stack. If they
wanted to sue _users_ of their software, do you think they'd start with your
company, or Bank of America, JP Morgan, etc.?

------
welp
This talk[1] by sogrady (originally presented at FOSDEM 2012) has a lot of
interesting statistics demonstrating the popularity of JVM-based languages,
and how they have been growing. The numbers come from sources including HN,
GitHub, Indeed.com and Ohloh. Definitely worth a glance through.

[1] <http://redmonk.com/public/fosdem2012.pdf>

~~~
SeanDav
Very interesting link. Just wish people would use log scales or split graphs
when trying to display data with orders of magnitude differences.

------
rurounijones
As a Ruby dev I am loving JRuby. It is fast, has access to serious app servers
like Tomcat and JBoss as well as java libraries, multi-threading like a
madman.

I get warm fuzzies when I do load-testing and see the response times go down
on a newly booted at as the JIT kicks in.

Plus it works well on windows when I have no choice but to use a windows
server.

With new JVM language frameworks like vert.x and the invokeDynamic etc.
additions in Java 7 I really really think the JVM is getting some good
mindshare in communities that otherwise would not have touched it due to java.

~~~
benmac
I wanted to love JRuby (Ruby 1.9 emulation) but bugs like this:
<https://jira.codehaus.org/browse/JRUBY-5529> causes HTTPS calls to services
like Stripe to fail. That bug has been open for over one year now.

Other bugs like this: <https://jira.codehaus.org/browse/JRUBY-6181> cause
Capistrano deployments to fail (but there is a workaround).

Lack of a clean implementation of something as fundamental SSL libraries and
the inability of the main committers to address those shortcomings pushed me
back to a traditional Ruby approach.

~~~
rurounijones
Ouch, I must admit that I use JRuby on internal facing windows servers (no SSL
required and, unfortunately, no capistrano) so have not run into these
problems.

------
cageface
If you take Indeed's data seriously, try plotting all of these languages vs
Java and you'll see that they are all baseline noise compared to grandpa.

In my opinion none of these pose any real threat to Java, for reasons specific
to each. The only JVM language I've seen that is enough of an improvement to
be worth the trouble but still accessible enough to the rank & file to stand a
chance is Kotlin.

~~~
thebluesky
6 years ago Ruby was also rapidly growing "baseline noise"...
[http://www.indeed.com/jobtrends?q=ruby&l=](http://www.indeed.com/jobtrends?q=ruby&l=)

IMHO Kotlin is less of an improvement over Java than Scala is. Mostly the
impression is Kotlin == the poor man's Scala

~~~
cageface
It still is, practically. It's also not really directly competing with Java
the way a lot of JVM languages are.

Kotlin is indeed much less ambitious than Scala but, as much as I like Scala,
I think it's just a bridge too far.

------
vorg
> Clojure fared particularly well (ahead of Scala and Groovy) in the poll I
> ran due to many of the voters coming from the LISP friendly HackerNews
> community. The DZone poll which drew a slightly larger number of voters
> (primarily Java devs. from the dzone community) favoured Groovy, with Scala
> in second place, followed by Clojure. In order to get a better picture of
> popularity spanning both polls I combined the results and plotted a chart.

You don't combine results to get a better picture of popularity. You ask which
of the two of them is less likely to be skewed with manipulated results. DZone
is a grossly commercialized entity compared to hackerNews, with rings of users
upvoting stuff they want to promote, and privileges for moderators of the
"subzones".

A better measure of popularity is O'Reilly's hard copy book sales for the year
to March 2012:

[http://radar.oreilly.com/upload/2012/03/Lang_QTR_Units_PrevY...](http://radar.oreilly.com/upload/2012/03/Lang_QTR_Units_PrevYear_a.jpg)

Just how would anyone fiddle that data?

------
readme
What this article misses is that the indeed statistics are potentially bogus
since many job postings will include phrases like "Looking for a Groovy
person" and are false positives, since the word groovy is an adjective here,
not a proper noun.

~~~
thebluesky
All statistics contain noise, but how many job postings are about groovy
programming vs the obscure edge case you mention?

~~~
vorg
Job ads mentioning Groovy are usually for Java devs with Groovy as a nice-to-
have addon skill, but job ads mentioning Scala are usually when Scala is the
primary language.

------
calinet6
What is a "JVM-based language"? The JVM is simply a virtual machine. One could
theoretically compile any language to run on this virtual machine. The
popularity is a testament to the maturity and reliability and ease-of-use of
the VM, but to say a language is a "JVM language" is no more accurate than
saying that C is an "x86 language" simply because x86 is the most popular
target architecture.

Details details...

~~~
thebluesky
What two word phrase would you use to describe the following set of languages
{JRuby, Scala, Clojure, Groovy} without turning the headline into a full
paragraph?

