Today we have the third part of the programming language job trends series. In this, we review Erlang, Groovy, Scala, Lisp, and Clojure. To recap, in part 1 we looked at Java, C++, C#, Objective C, and Visual Basic and in part 2 we had PHP, Python, JavaScript, Ruby, and PERL. You may be wondering why your favorite language is not included. In some cases, like Go and Haskell, there is too much noise in the jobs data to give a useful trend. In other cases, there just might not be enough demand yet, but admittedly, I was not exhaustive in my research.
First, let’s look at the trends from Indeed.com:
If you read the previous two parts of this job trends series, you will notice an obvious difference. These trends are not all declining. Groovy has a somewhat flat trend on average for about 3 years. Scala is not far behind Groovy and has a somewhat rising trend over the past 2 years, with much of the same bouncing as Groovy. As you can see, there is a significant gap between The first two languages and the others, which should probably be expected. Clojure and Erlang have converged to the same point in the past year, but they came from different directions. Erlang has a fairly flat trend (maybe a slight decline), while Clojure is growing steadily for about two years and only flattened during the end of 2013. Lisp trails them all with a slowly declining trend over the past 3 years. I included Lisp for two reasons, to give me a baseline and to see the differences between it and a hyped dialect (Clojure). This graph also confirms one of my theories, that people are starting to look at languages outside of the Java, C#, Python and Ruby crowd.
Now onto the short-term trends from SimplyHired.com:
SimplyHired is showing trends very similar to Indeed over the short term. Granted, the trend lines for Groovy and Scala do not bounce as much, but their relative position and grouping are definitely similar. For the other languages, the grouping is even tighter with Clojure having a small lead, Erlang following and Lisp trailing. The main difference between those trends is that Erlang is declining while the others are more flat. Please remember that the SimplyHired data is about 6 months old, so it is only useful when comparing the languages to each other.
Lastly, we look at the relative growth trends from Indeed.com. This compares percentage growth as opposed to percentage of all postings:
The relative growth definitely shows much more interesting information. First, groovy continues a ridiculously high growth trend (about 50,000%) and seems to have stabilized there. The only problem is that the Groovy growth skews the graph. So, if you look at the graph without Groovy, you can see more details. Scala leads the pack with growth at 7500%. Erlang follows but has a declining growth trend, which does not bode well for the long term outlook. Clojure barely trails Erlang but has a rising growth trend, which matches the buzz you hear about Clojure in the tech world. Lisp has a flat growth trend, which is not really surprising.
Overall, these trends give a fairly positive outlook for the programming industry growth. The previous two installments made the industry growth look flat, but this installment points to more breadth in the languages being used. The trends also seem to match the buzz seen on blogs. Groovy, Scala and Clojure are popular topics, while Erlang gets some publicity but not much. Lisp barely gets talked about on the mainstream blogs, but does appear on some machine learning and artificial intelligence sites. I think it is clear that if you are looking for a hot new language to learn, and you want it to have real job potential, Groovy and Scala are good targets but keep an eye on Clojure in 2014.
