When we introduce Scala into a organisation, at some point we find someone who makes one or both of these assertions:
- Scala developers are “expensive”.
- Scala is hard to understand.
We’ve tackled this a number of times and would like to share the results of our fact finding and experience.
In this post we’ll look at the misconception of Scala developers being expensive.
Java and Scala rates are about the same
Cost is relative, and the idea of Scala developers costing more is usually in the context of a comparison to Java. The idea, in the least-sophisticated form, is: there are lots of Java developers, so that must mean they are cheap; there are less Scala developers, so they must be expensive.
It’s an understandable starting point, as there are 9 million Java developers, but it is flawed by two facts:
- Java developers and Scala developer rates are within two per cent of each other.
- It is more productive to develop in Scala.
The data on rates
Looking the data from Indeed.com we see that this year, and further back, Java and Scala rates have oscillated above and below each other. The difference, given by Indeed.com is that the “average Scala Developer salaries for job postings nationwide are 2% higher than average Java Developer salaries for job postings nationwide.”
Those are the market figures. We can also add that from the developer circles we move in we know some Java developers will take a reduced rate to use Scala; some now require a higher rate to consider a Java contract over a Scala one.
The conclusion we make is that it’s a huge stretch to call a two per cent difference “expensive”, especially given the experience on productivity.
The data on productivity
Scala was not just built with productivity in mind, it was the central drive. There are plenty of experience reports showing that gains are being delivered.
When The Guardian moved to Scala from Java the management reported projects not being materially effected during the transition, and then being more productive after about three months. The developer experience is of writing less code, producing higher quality code, and delivering faster by focussing on the problem not boilerplate.
In terms of research evidence there is less to drawn on. A summary by Phil Bagwell of recent findings, points to eye tracking experiments that show developers are faster to see what’s going on in Scala code compared to Java due to the more concise syntax.
Having said that, it’s not going to fit well for everyone or every team. Obviously. But for the right team, the gains are there to be taken.
Scala: more productive, not more expensive.