Why do Java programmers love Scala and shy away from Clojure?

Question

I've just started to learn Clojure by reading some tutorials and watching every presentation by Rich Hickey, and I'm totally impressed by the language... so different from any C-like language (actually any language I've seen so far), yet so elegant... So I started to wonder... why is everyone so thrilled by Scala but not by Clojure? Is it because Scala is more Java-like? Because of Clojure's parenthesis? Because it's functional?

Clojure's interop with Java looks very good, performance seems okay, and while the syntax is weird at the beginning, it all makes sense if you see the reasoning behind all this.

So, what are the reasons?

Answer 1

Most people just don't like LISP. I don't think there's much else to this phenomenon than just that.

Answer 2

I think it's almost completely related to syntax. Java programmers are used to curly brackets. However, the majority of people coming to Clojure appear to be Java programmers, so I'm not sure this is entirely accurate. Plenty of Java developers like Clojure.

Answer 3

Scala is much more like Java than Clojure. Scala's object system is at least recognizable to that of Java. The syntax is fairly similar. Integration between Java and Scala components is easier (in my opinion). Scala and Java are both statically typed.

Clojure, on the other hand, is rather different than Java. It emphasizes functions over objects. Its syntax is radically different. It's dynamically typed.

Answer 4

As Rich says, clojure is not for everyone or every type of problem. He wrote it to solve the kind of problems he works on. So the type of projects someone is coming from are going to play a big role in how much value they see in Clojure. If they are coming from distributed data processing for voting systems they will see more value than if they are coming from a career writing swing gui's for instance.

The syntax is a bit different and people seem to get over that if they see enough value in the language to justify the effort of learning a new syntax.

Answer 5

EDIT - below is exactly why I shied away from Clojure so whether you like the reason or not, it is a correct answer and not deserving of downvotes (in my opinion). I would like to re-iterate the point made in the comments below:

Whilst Rich Hickey is most likely a genius and a great guy, he created Clojure because Java didn't seem a good solution for the problems he was coming across in his work - given the fact that he didn't have the background of Odersky (explained below) and given that this is exactly the reason why we have 20 gazillion Java web frameworks, I approached Clojure with the suspicion that it would die a death when Rich decided to move on to his next thing.

This one of the genuine reasons why I did not invest more time in Clojure and I believe it probably goes for others also, whether you like it or not.

---

Martin Odersky, the creator of scala, essentialy wrote the Generic Compiler for Java (and his language, Pizza, actually became generics-for-Java). This is an excellent pedigree and meant I could have a lot of confidence that scala would have some serious longevity! Unfairly or otherwise, it seemed like Clojure was a language created by some guy, in the same vein as the yet-another-web-framework mentality.

At the time I chose to migrate across, EDF, Twitter and other serious companies were using scala. I could be reasonably sure that Scala was a usable language within the enterprise (even with its academic roots).

Then I took a look at the Clojure syntax and... There is no way I was going to succeed persuading myself that migration would be easy, never mind my colleagues!

Answer 6

Subjective:

History has shown that C, C++ and it spawn is very popular and since Scala is simular to C++, Java and C# the learning curve going to Scala is low or nonexistant if using only the OOP parts compared to switching to Lisp like languages.

Hovever I think Lisp like languages are very popular in certain fields such as NLP, yet there is work done in Scala in said area.

Answer 7

Humorous:

To quote "A Brief, Incomplete, and Mostly Wrong History of Programming Languages" by JAMES IRY

1958 - John McCarthy and Paul Graham invent LISP. Due to high costs caused by a post-war depletion of the strategic parentheses reserve LISP never becomes popular1

While

1Fortunately for computer science the supply of curly braces and angle brackets remains high.

Answer 8

Clojure is a dynamically typed, Lisp-derived language with syntactic macros. Scala is a statically-typed, type-inferred language with a bunch of advanced features in the type system. As such, the difference between them is rather stark; apart from the fact that they both support more interesting concurrency primitives in their standard library than Java does, they're really very different in approach.

I think a lot of Java programmers are more comfortable with Scala simply because, in a large number of cases, the process of converting a Java class to a Scala class involves moving the type declarations to after the variable names, and with a couple of other minor syntactic tweaks you can have a functional Scala class that compiles to nearly identical bytecode to the Java version. This means that the learning curve for adopting Scala can be essentially as shallow or as steep as you want it to be. When moving to Scala, it's likely to take you longer to convert your build infrastructure than it would to convert any given class... and if you're using Maven, all that converting your build system requires is adding a plugin to your pom.xml.

That being said, I think that there's a great need for Clojure-style syntactic macros in real-world applications in most language, because even with an advanced language like Scala there ends up being a huge amount of structural repetition. You can see evidence for this in the fact that the Scala compiler itself provides what is essentially a macro system for class generation in its "case class" and closure/function literal syntax features. The fact that such a macro system was not exposed to the end-users of the language is something that I really hope will eventually be remedied.

Answer 9

I am a professional Java developer, I don't love Scala, but I do find Clojure very interesting, let me tell you why.

My first experience of Scala was back in 2008, I took a university course on the subject. It felt syntactically quite odd, the IDE support was bad and I didn't understand functional programming at all. I still managed to finish the course work by coding Java in Scala.

9 months later I had a course on functional programming in which we used Haskell. It was a bit of an eye opener and I thought I must try Scala out again. Haskell I dismissed as being a bit too academic.

Last spring I had some extra time and I decided to give Scala a new chance. Many of the annoying niggles that I suffered from the last time around were still there. Big API changes between releases, guessing when the compiler/parser requires parenthesis or spaces, IDE support still sucked, odd syntactic constructs that forced you to think really hard what the hell is going on, and compared to something like Haskell it was very verbose. As an example of my last point I'd like to give the map function signature from Scala.

def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That

I really really tried, but I just didn't feel I was getting my money's worth. I felt, and still do, that Scala is just a better Java. Lots of neat concepts like traits, type inference etc. but the ecosystem around the language is still too fragile. This ruled it out for work usage. The fact that coding Scala didn't feel even close to as much fun as Lua or Ruby basically made it a complete dud from my perspective.

And then we have Clojure. Being a Lisp its code examples such as #(* %1 %2) makes you think it telling you to go f*** yourself. I dismissed it early on as being not a real world language, too hard, basically the same as Haskell.

This summer for some reason I decided to watch a few video presentations of Clojure by Rich Hickey. I got interested. The language still looked odd, even basic concepts seemed very difficult and confusing, but a lot of things just made sense. The strong focus on immutability was one of them, a very strong focus on Java interoperability was another. Scala is in many ways closer to Java, but does it honestly make coding Java any easier? The most vocal Scala enthusiasts want Java to go '{ :fu "ck" } itself.

I am still a total Clojure noob. Not coming from a Lisp background I find the language scary powerful. But besides finding a lot of the key concepts very sensible, I also think it is fun, something Scala just wasn't, no matter how hard I wanted it to be.

Answer 10

Martin Odersky has said that he views object-oriented and functional programming as complementary, and puts the two paradigms on roughly equal footing in Scala. However, looking at the Clojure website, I get the impression that Rich Hickey is somewhat hostile to OO and views FP as a superior replacement to it. As such, Clojure will definitely have a much steeper learning curve coming from Java, to say the least.

Answer 11

I work in a Java shop and I can tell you that my colleges would be fearful of both Clojure and Scala. Fear, because it would to their mind invalidate everything they had invested in Java. I have seen it many times when I have tried to show them these languages (I know, I'm annoying).

The FUD that they come out with shows their uncertainness.

"The syntax looks funny/hard"

"I can't refactor it with (insert ide here)"

"I could write that faster in Java"

"They are slow"

Now they may be right about some of these fears. Learning a language takes time and you will go back down to the level of a beginner for a short time. But I think it is worth it just for the benefits learning new language will give you. It shows you how to think about problems in your old language new ways.

I really think it comes down to the The Blub Paradox.