Tag Archives: Jython

Job Ads Are A Valid Indicator Of Programming Language Acceptance

I found an article from a mystery blogger here called Job Ads Do Not Reflect Programming Language Popularity that covered my post on Scala, Groovy, Clojure, Jython, JRuby and Java: Jobs by Language. It’s well written and pretty fair and I think that anyone who found the my original article interesting should go over there and read it. That said, there are a few points that I’d like to expand on if you will indulge me.

1) The job percentage of 3.5% for Java is across ALL jobs on indeed.com not just IT related ones (there are 2x as many Java jobs as there are listings for accountants 🙂 ) which makes the 3.5% value quite respectable.

2) The stats do seem to imply that Scala and Groovy have far more momentum than Clojure. I know some real Clojure fans but compared to the relevant Scala and Groovy user groups they seem to be a little more active. Also, both Scala and Groovy have killer weapon in the Akka and Grails frameworks. I don’t know if the same can be said for Clojure (Noir?) and would be happy to be proven wrong. I don’t think that the importance of having these weapons can be underestimated. It gives both languages great leverage in getting in the door of businesses and once they are in the door then I would expect more general usage to follow.

In the original article I showed the graph below and mentioned that it was likely that Scala would overtake Jython and that in fact, Scala’s growth rate had overtaken Groovy’s (although with a caveat that it was only a few data points and so could be a ‘flash in the pan’).

Now this is the same graph 6 weeks later…

It looks like I was right on both predictions (cue outrageous smugness!) but they both seemed reasonably obvious. The one thing I did not guess was the Groovy’s grow rate would have stalled like it has. I hope it’s only temporary.

The author goes on to give a very good time line of the development of a language but doesn’t mention that crossing the chasm is the hardest thing for any language and that’s where both Scala and Clojure are right now.

3) I completely agree with the average Java developer caring less for programming since it is currently the default language of the majority. By this fact you will find more close-to-the-mean programmers using it than any other language. Given the volume of jobs out there the stickiness of the jobs can’t be that different and because of this I think that job listings are a valid metric of the industry acceptance of a language. Even if they are only slightly indicative, you would have to show that jobs in other languages are 60x stickier to be on a par with Java or that Clojure jobs are 6x stickier than Scala jobs.

4) I hope that I never gave the impression that if you are a Java developer that you shouldn’t bother to learn new JVM languages. I completely agree with my mystery friend that knowing new languages makes you more employable. As someone deeply involved in the recruitment process at my current employer I can personally attest to this. I would go as far as to suggest that knowing more languages makes you a better programmer since it exposes you to more ways of doing the same thing. More tools in your toolbox gives you a better chance of picking the right one and using it correctly.

As for whether my final paragraph was too strong, I can only say that I call ’em as I see ’em. Yes I am a bigger fan of Scala and Groovy than I am of Clojure but please don’t take this as evidence that I am somehow against Clojure. Clojure is a beautiful language but it suffers from the fact that it lacks the aforementioned ‘weapon’ and is just so different from Java that companies will shy away from it worried about how long it will take them to spin up their entire workforce, not just their elite teams.

Maybe I can phrase it differently this time; it doesn’t matter whether you are a Java developer or not, the best thing you can do is to read “Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages” by Bruce Tate. Learning Ruby, Io, Prolog, Scala, Erlang, Clojure, Haskell will do great things for anyone’s understanding of programming languages.

 

Scala, Groovy, Clojure, Jython, JRuby and Java: Jobs by Language

In a previous post I pointed out that one of the more obvious recent changes in the Java landscape has been the meteoric rise in popularity of other languages for the JVM.  Some are old and some are new but JVM compatible versions of established languages with the likes of JRuby and Jython, Java-esque languages like Groovy and Scala and brand new languages like Clojure and Kotlin offer genuine options for those that appreciate the performance and reliability of the JVM but also want a different syntax.

In an ideal world all developers would be able to develop in the language of their choice. The reality is that as developers we are constrained by the suitability of the language, the tooling support and by what languages companies are actually using. Firstly, you choose the language appropriate to the domain – one that lets you do your job quickly and easily but with the appropriate level of support for your non-functional requirements like performance.  Secondly no one wants to be slogging through the coding process in a simple editor. Yes, I know that we could all use vim or emacs but being able to refactor large swathes of code easily and quickly (hello TDD!) kind of demands a modern IDE like IntelliJ or Eclipse. Thirdly, the reality of the situation is that very few of us are in the position to be able to dictate to our employers what language we should be using. Learning a language with rising popularity also means that you have a greater chance of being employed in the future (which is nice) but employers drive the acceptance of new languages.

The fact is that many companies boast about using the latest and greatest languages since it makes them more attractive to candidates. You can barely move for the blog posts and tweets of people raving about how their company has completely changed their development process with a new language but what is the real picture?

For a useful indication of industry acceptance we can go on the job trends on indeed.com. The grand daddy of language charts is Tiobe but it’s no use at this point since a) it does not provide sufficient information and b) is too easily gamed – yes Delphi dudes, we know what you did. Now before you complain, I know that using something like this is far from perfect and a long way from scientific but unless you fancy doing a longitudinal study going asking all the companies what they are using and believing their answers are real rather than marketing fluff, it’s probably good enough to be illustrative.

So what can this tell us about the how the industry sees the major language of the JVM: Java, Groovy, Scala, Clojure, Jython and JRuby*. What happens when we have a look at the percentage of all jobs that mention these languages

Umm, well… it’s pretty obvious that despite all the industry noises about other languages, Java is still massively dominant in the job marketplace with almost 3.5% of the jobs requiring Java knowledge. We all know that Java is an industry heavyweight but it is a bit of a surprise that in comparison the other languages are an indistinguishable line. Welded close to the 0 line, they would need some seriously exponential grow to start to threaten Java.

So what happens when you remove Java….

This is a lot more interesting. Firstly Jython was the first language other than Java that was really accepted on the JVM. Groovy started to pick up in 2007 and quickly became the first of the alternate languages, no doubt driven by Grails. Clojure and JRuby have never really garnered much support despite the recent rise in the last 18 months or so. I think the most interesting point is the recent increase in the acceptance of Scala. Currently third behind Jython, the gradient indicates that it will soon move into second. Comparing the grow rate of Scala and Groovy on a relative basis we see the following.

So we can see that Scala has finally crossed over Groovy’s growth rate. It’s completely reasonable to say that this could be temporary and that we should not read too much into this but there are a few data points there so it does not appear a flash in the pan.

So what can we say; while you’ll want to dust off the old Groovy text books and maybe have a look at some Scala tutorials, the best thing you can do is to keep your Java-fu in top notch order. As far as the industry is concerned Java is still the Daddy of the JVM languages and seems to being staying this way for some time.

* – I did originally include Kotlin and Gosu but since there were 0 jobs for Kotlin and only about 9 for Gosu they would only have been noise.

The First Class Languages of the JVM

The announcement of Kotlin, a JVM based language from JetBrains, drew quite a bit of attention. Firstly, when the makers of the best Java IDE in the world announce their own language you pay attention and secondly, it wasn’t that long ago that to the average developer the JVM meant Java and only Java and the rise of other languages on the JVM was some sort of bizzaro dream. While Jython (1997) and JRuby (2001) predate Groovy (2003-ish) it was the latter that really seemed to show everyone that something other than Java could be run on the JVM. The fact that Groovy is a super-set of the Java language meant that the barrier to adoption was very low and developers seemed to lap it up. This encouraged adoption but the push from the likes of SpringSource and the rise of Grails piggy-backing on Ruby on Rails’ success seemed to drive its acceptance. Even the fairly poor tooling support seemed to not be too much of a barrier as many companies started using it and benefiting from something other than Java.

Kotlin’s emergence does raise an interesting question;  from the developers perspective, what are the first class languages for the JVM right now and who will be in that list in 3-5 years time, and more importantly why?

Of all the languages that can run on the JVM, I would say that the the list of the premier league languages can be restricted to the following: Java (natch), JRuby, Jython, Clojure, Groovy and Scala (Kotlin is interesting but until Jetbrains write IntelliJ in it I won’t take it too seriously). Of these 6 languages it also interesting to note that only 2, Java and Scala, are statically typed and 3 are versions of a previous language: JRuby (Ruby somewhat obviously!), Jython (Python) and Clojure (Lisp dialect).

Scala has been seen as the language most likely to supplant Java but its complexity (especially the multiple different ways you can write and do the same thing) has held it back. It’s functional nature has also meant that many Java/OOP developers freeze in the headlights when Scala code switches to this mode. Scala is awesomely powerful and the likes of Twitter, Foursquare and GridGain use it in missions critical systems but it currently lacks that magic sauce that makes it accessible to mere mortal developers.

The same goes for Clojure. Lisp and its dialects has never really found a massive following in the commercial environment despite being held in high regard elsewhere. Even with the increasing interest in functional languages it still does not have the momentum required to be wildly successful but it is still early days for Clojure.

Ruby (1995) and Python (1991) are not new languages. Since there appear to be about 3.5 times as many jobs currently being advertised for Java than for Ruby and Python combined  it appears unlikely that even JVM friendly versions of them will be the next big thing. Don’t get me wrong, Jython and JRuby are great languages but they are hardly new kids on the block.

Groovy‘s similarity to Java makes it’s adoption very easy but its performance historically has not not great. I’m being polite since it’s actually sucked pretty hard.. Whether this is still an issue with the inclusion of JSR 292 in JDK 7(Supporting Dynamically Typed Languages on the Java Platform) remains to be seen but the dynamic typing does not tend to be as accepted as static typing in the enterprise context. I know this is a contentious point but Nuxeo moved from Python to Java and Twitter’s adoption of Scala indicate that context is important: if you have a large-scale performance orientated application, static typing is your friend and this is where Java is used heavily. Should you really like Groovy’s syntax and want static typing, Groovy++ offers what you need but again, does it offer enough to replace Java. I’d have to say no.

So what will be the language that retires Java? I have no idea and I don’t think that anybody else does either but I suspect that the language that finally does has not been written yet. It appears that the usage of Scala, Groovy, Clojure, Jython and JRuby will increase in the next few years but none of them seem to be the Java killer. The increasing adoption of languages with better type systems than Java seems assured for the the next few years but none of them seem to offer the combination of features to supplant Java.

If I had to back one of the runners, Scala appears to be the one with the most momentum as well as arguably the most power and functionality. The perception of complexity can be dealt with by education and training so it may well grow to be a contender to Java but given the learning curve, it is hard to see it ever replacing it. Who knows, it may be a language from an IDE company that finally sees Java developers cry “The King is dead, long live the King.”