At the company I worked at previously, the case was often made that java should be used because it's easy to find java programmers. That sounds plausible, but in practice we found it very difficult to find good java programmers. Perhaps to some extent it's even harder than with other languages, because a lot of really talented people are drawn to new shiny ecosystems -- not saying java folks aren't talented, but as a java programmer myself, I see many of the most driven/passionate people wanting to get away from java.
> if a company chooses to write its software in a comparatively esoteric language, they'll be able to hire better programmers, because they'll attract only those who cared enough to learn it.
I cant help but think of Jane Street Capital's use of OCaml when reading that line. From what I understand there are some extremely bright people writing fantastic code over there.
I consider myself very fortunate to be coding in Scala. I know of many Java developers who code Java at work and wish that they could land a Scala job.
I've had only one project in Scala and in general I really liked the language. My biggest reservation about Scala though is what I consider the over-DSLy-ness of some of the Scala libraries (3rd party libraries).
In my project different source files using different libraries could almost look like different languages due to the DSLs of the libraries those source files used. Maybe it's just my lack of experience with Scala, but I dislied this because I thought it reduced readability.
Even worse is when two or more DSLs in use in the same source file conflict, for example, with their implicits. Then you may be stuck with different source files using the same library but with different syntax, one with the DSL syntax (where there were no conflicts) and one without.
I suppose this is something you get used to with Scala, but I wonder if you've run into this and if so, what your reaction to it is?
Luckily it seems like this is becoming a less common practice in library development in Scala. As the Scala community matures, people are starting to shy away from abusing Scala's DSL features.
The type system. Performance from benchmarks appears to be better. Also, I suppose that interaction with Java code is more natural, since Scala is a weird mix of object-oriented and functional languages.
On the other hand, the compiler is extraordinarily slow.
The way it combines functional programming with object oriented programming. This kinda gives you the best of both worlds (others may refer to it as 'frankensteinian' though).
People have mentioned type system, performance and closer semantics equivalence with Java, but the real advantage in the wild is that Clojure's syntax (or lack thereof) is alienating to most people.
I've been working in a Scala shop for the last year. Once you've begun to take advantage of the type systems, monads, and writing in a functional manner, Scala becomes a extremely pleasant language to work with and significantly improves productivity.
Java wants everything done in its way, and its way is painfully, needlessly verbose, and weak at expressing algorithms in a way that encourages bugs. Also Java's conventions and culture magnify its verbosity, it's popular libraries and extensions are over-engineered, and its package file format lacks versions and versioned dependencies, producing inevitable conflicts. It's slow to start up and a memory hog. Really the only advantage is that it's fast.
The other JVM languages reduce some of its flaws. Go, I have found, avoids them all.
Mostly because the Java syntax has remained (mostly) unchanged since September 2004. Java 8 will change that, but it's still a far cry from what's available in Scala.
Thats does not sound like the whole truth. I would guess that Java long ago lost its sexiness - now everybody and everything uses Java. The other problem is that now there is vast amount of legacy code. By choosing Scala you are actually eliminating that from the equation.
I disagree with the other responses at the basic level. I think this is a simple supply/demand response. There is an over supply of Java developers. This means that many of them are looking to alternative languages to differentiate their own skills for others. This is particularly true among Java "leadership." Where the heads of the languages have been increasingly visible in other languages.
That's an interesting reversal of the logic in the paper. I assumed that the programmers looking for the next cool languages were doing so in pursuit of novelty and not doing it for economic reasons. I wonder how you could empirically support one or the other hypothesis.
Well, sadly, I basically have no idea on how to explore my thought here. Really, all I have are some platitudes. "Go where the money is," combined with "Don't go where everyone else is going."
So, yeah, I would be curious on how to support either hypothesis, as well. Best I could think would be to track job listings. While I think you will get a few folks doing things for the novelty and to make it work. I think the majority entering an industry are chasing the buck the last success made.
