How fast are JVM-based languages growing among developers? | Hacker News Reader

How fast are JVM-based languages growing among developers?

blog.jelastic.com

63 pointsMarinaSprava39 comments

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.

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...)

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.

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.

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.

Actually, ClojureScript worked just fine in Rhino, JS implementation that ships with the JDK, last time I checked.

Fantom has had support for the JVM and the CLR since it first came out. It has subsequently added JavaScript as an output language.

I've been wondering why Fantom doesn't seem to get the respect or play that some of these others have. Is it because it courts both camps, so neither wants to use it? It's a neat language, although perhaps not very revolutionary compared to these.

Microsoft and the Mono Project have both doubled down on C# as their language of choice for the CLR. Rather than really push for greater adoption of F#, it seems that they're letting F# incubate functional programming concepts, which later trickle down into C# for more mainstream developers.

Looking at the JVM, it seems like a similar dichotomy is happening with Scala, although more slowly without a Microsoft-like corporate shepherd.

Java and Groovy still have the mainstream developers' attention, but Scala is slowly growing mindshare. Clojure, much like F#, still seems to remain in the realm of the hobbyists and early early adopters.

My feeling is that C# as a language is getting close to being full of features. Microsoft have done a really good job of adding things to it so far without turning it into a hodge-podge, but if they keep going at the same rate then it seems inevitable that they'll either have to let it get messy or do a big redesign.

I'd agree with this, but I think the reason that more .NET developers don't revolt is because there seems to be limited uptick on some of the newer features.

E.g., generics were introduced in .NET 2.0 around 2005, but it was very common to find .NET shops where you didn't see them used in the code even as late as 2009. Same goes for Lambdas in .NET 3.5, and Dynamic objects in .NET 4.0. The corporate install base just tends to be more conservative with picking up new language features.

I think it's more likely that a big redesign will come and a new language will get introduced in a few years.

Honest question: Do you get the sense that the type of programmer who really likes .NET is one that goes for "alternate" languages? I've had limited exposure, but I do not get this sense; rather, the ".NET guys" I've been around fall into 2 basic camps: 1) They want to just do the minimal problem solving required for their role and don't really care about technology for the sake of it, and 2) They have bought into the MS ecosystem, and will just go with that flow.

Basically, they're not hobbyist or "I code because I love to" types; which are the (IMO) more curious and invest time in new things, just because.

I think that's a fair assessment, and it's one of the reasons I left .NET about a year ago.

The average .NET developer usually works in a 9-5 corporate environment that is completely bought into the MS ecosystem. This environment has traditionally been very opposed to Open Source and discourages hobbyist programmers as a result.

There are hobbyists and "I love to code" types in the .NET community (many will likely jump into this HN thread) but there are comparatively fewer hobbyists in the .NET community when compared to other communities.

It doesn't matter if the CLR is supposed to be the future of cross-platform languages. It is irrevocably tainted by Microsofts primary focus on the windows platform.

A new language is extremely vulnerable, more so that properly anything on earth, and its chances of adoption are exeendingly rare. You just cannot afford to cut of the couple of hundred early users because your language only works, or works best, on Windows.

Clojure is 4-5 years younger than Groovy and Scala.

If someone could find me some scientific data on usage (I've been working on this for a while with other languages) I would love it. Seems we will always be stuck with "non-scientific," volunteered information.

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?

> 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.?

Oracle may not have made many friends among Java devs, but it's pretty ridiculous to suggest that developing a Java app is going to put you at risk of anything. Have you violated the license terms of the JDK (GPL 2)?

Unless your project is an incompatible Java fork you don't have anything to worry about.

Has anyone EVER been sued for simply using standard Java? Can you picture all of IBM's Java-using customers being sued?

I am not talking about a simple app developed using Java, I am talking about making a JVM based framework based on a fork of JRuby and JVM. Is this against some license?

You can fork the JVM, but the patent license will only cover you if you are pass the compatibility kit, which Oracle may withhold whenever they feel like it.

So from a copyright perspective you are fine (that's the point of the GPL) but from a trademark perspective you may not call it Java, and from a patent perspective there's nothing stopping Oracle from attempting to crush you in jurisdictions like the US with bad patent laws.

Hmm, probably not (if your code is GPL), but you really don't want to fork the JVM (unless your name is Cliff Click). It's one of the most complex pieces of software ever written, and it's the most performant managed runtime out there. It's used in anything from tiny electronic devices to huge data crunching applications, from hard real-time systems to distributed batch processing. And, it has to be maintained for a lot of different CPUs and OSs (all work you'll have to do if you fork it).

On the off chance you could make a very specific use case slightly faster on a non-compatible JVM (which, BTW, you'll not be allowed to call Java), it is certainly more trouble than it's worth. Just use it. The entire world does.

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

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

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.

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.

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.

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.

6 years ago Ruby was also rapidly growing "baseline noise"... 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

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.

> 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...

Just how would anyone fiddle that data?

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.

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

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.

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...

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?

Not all languages have a formal spec. Many are implementation-defined. You can turn your nose up at them if you like, but they still exist.

C happens to be most often compiled for x86, but the language isn't designed primarily to target x86. On the other hand, languages like Scala, Clojure, Groovy, etc. do intentionally target the JVM and tout Java interop as a feature. Other targets are secondary (or nonexistent) not just for the users, but for the language designers themselves.

>What is a "JVM-based language"? The JVM is simply a virtual machine.

No, it's more specifically a virtual machine designed, with the Java language primarily (if not exclusively) in mind. Where do you think the J in the JVM comes from?

>One could theoretically compile any language to run on this virtual machine.

And that language implementation would then be a "JVM based language". Duh!

Reply on news.ycombinator.com