Just to reiterate what the other Andrew said, learning the basics of Haskell is easy. It is only when you want to learn the advanced topics that it becomes more challenging. And, even then, most of the stuff is easy to learn to _use_, despite being difficult to _understand_.

However, the problem with it is the ability to distribute software to other people, as it generally requires them to have the entire Haskell toolkit installed. So, like you I am investigating JVM languages.

That said, if you are writing software for your own use, I can’t recommend Haskell enough. It is the fastest and easiest language I have ever used, and I do all of my prototyping in it. And, when I don’t have to worry about distributing software, I do all my large scale development in it also.

Thanks for the comments. You have to be the first person I have ever heard say that they thought Haskell was easy! WOW – you are clearly WAY smarter than I am !

So basically I had an app that was written in Java (using GWT) and wanted to modify and extend it. So I wanted to use a JVM language to be able to interoperate and modify over time (it is sort of a side project for work and I cannot commit as much time as I want). That is how I came across both Clojure and Scala. For me interacting with Java was key.

I was – at the time – just starting to learn Lisp and really was amazed with it. I find it beautiful to look at. Unlike so many programmers, the S-expressions were wondrous to me! Go figure. I started reading some stuff about Lisp and got hooked (go to defmacro.org and read this guys stuff – if you werent interested in both Lisp and Haskell you will be after you read this stuff). I am more of a hobby programmer and do a lot of prototyping for ideas that I have that, if adopted, get turned over the an enterprise development group for programming. So Clojure is ideal for that sort of stuff.

I do not have alot of experience working with the Scala community, but the Clojure community is SO amazingly helpful and friendly. I ask myriads of stupid questions and people supply amazingly long and detailed answers – including Rich Hickey himself). I think that has helped my transition to Clojure as well.

Thanks for the post. Please feel free to provide into on your genetic programming experiences. This is some confusing stuff for me!

Much of what you say is true – people take one look at Lisp and think yuck. The fact is once you’ve used it, as you have, the simple elegance of the homoiconicity leaves a lasting impression with you.

Not only are macros possible but the interchangeability of code and data enables far more flexibility to programming. This is difficult for a Java programmer to grasp but imagine writing your programs in XML where some tags are are code and some are data that are passed in and you can control which are which and effortlessly extend where necessary. You have the expressiveness of XML with the power of a programming language behind it – unlike Java where they are two completely separate things.

Anyone who is put off by prefix notation and hasn’t tried it are doing themselves a disservice – with a decent editor you don’t even see the parentheses.

I’ve done genetic programming in Scheme (another Lisp) and in C – it was simple in Scheme but in C, I basically ended up building an entire Scheme interpeter to do it. The C code was much faster though after I’d eventually fixed all the core dumps !

I’ve also used Haskell which is a beautiful language that makes Scala look clunky and it’s good to see that Clojure has adopted many Haskell influences like lazyness, purity and support for monads. Pure Haskell is pretty easy to learn if you know Lisp and the syntax is very succint. The type inferencing and automatic currying are fantastic. The problem comes when step outside purity as getting your head around monads takes some doing.

Now I’m back on the JVM looking for a language for rapid prototyping that can integrate with enterprise libraries – hence coming across this blog. At the moment I’m leaning towards Clojure because I will be able to use HOF’s to compose functionality and can make immediate use of some Scheme macros that should port quite easily.

I would prefer a Haskell-style static type inferencing system which Scala goes some way to provide but it is really just another OO language with a few functional sweeteners thrown in (a bit like Ruby) rather than a truly functional language. Scala is probably a good stepping stone for imperative programmers to experience some functional capabilities but I’m already on the other side of the river – I don’t want to go back.

Thanks for post – it was useful.

I have fiddled with both and think that both have their advantages and disadvantages (as do all things).

I would like to add my 2 cents on this one point:

“I do not buy the argument that Lisp is so much more powerful than e.g. Scala – so this doesn’t influence me much.”

Lisp(s) (including Clojure) have some things going for them that most other languages do not have.

Lisps are incredibly expressive languages. You can do so much with so little it is amazing. This is more true IMHO than in Scala, though Scala is substantially better than Java (setting the bar low, I know…)

Also, the macro system is simply amazing. To me that is the deal breaker. It extends the power of the language in ways that you simply cannot do in other languages.

Finally, it took me a while to fully understand this one aspect, but when I came around it really hit me like a ton of bricks. The homoiconicity of lisps makes for designing certain types of programs much easier. I am starting to dabble in some genetic programming and I have to say that I cannot even really understand how one could do this in a non-lisp (or at least non-homo iconic) language. To think that some people did this in C!!! Holy Toledo!

The more I read about Haskell the more I am interested, though it seems like a nightmare to learn. However I am consistently amazed how much people can do in so few lines of code. Maybe a Haskell implementation on the JVM is next???

While I am really impressed with Scala and love some things about it (patter matching!!) I have to say that programming in Clojure is the most fun I have had hacking away in front of a computer. I am starting to get to the point where I am realizing the productivity gains of these languages.

Life is good!

Cheers
Another developer

“cirlces” => “circles”.

Thanks.

“Your previous post supported Clojure… !?”

I do not support either, but share my opinions of both. But I’m mystified how you came to that conlusion as I did write:

“I think the object oriented features of Scala make the language more usable for real world applications.”

Everybody needs to decide for himself what language to chose. I chose to use one, I do not support one :-)

Now ur supporting Scala !!! Your previous post supported Clojure… !?

See with time opinions change !!!

I like people who have double life, mind and character.

Cheers,
Bob Me

Perhaps they’re still using Jython, which was released 12 years ago. It hasn’t advanced much, but it’s still good enough for scripty things. They can even put “Python” on their CV’s.

1)definitely suffers from some warts due to having to cope with the Java heritage side of things.

2)IMHO, Python remains the best language I have ever come across syntactically in terms of being “easy to understand, intuitive, powerful and pragmatic”. I was somewhat disappointed just how much more work it was to get up to speed with Scala. Won’t get into the typed argument etc – but rest assured if you have only a little time to get another language under your belt then i’d recommend Python – Java and Python make a powerful punch combination for developers in the field.

One good approach may be to code the reusable core / generic (framework-like) stuff in Java, so that it can be easily used in any JVM-language. And the specific parts can be coded in any JVM-language you feel most productive with.

An example framework is here: http://bitbucket.org/kumarshantanu/jettify/

Just to show how easily Clojure integrates with Java frameworks (Hibernate and StringTemplate) source code for a tiny personal blog app is here: http://bitbucket.org/kumarshantanu/blogjure/

A small request regarding your blog: do you think you could stop posting Twitter mentions in your comments? (or maybe have a separate section just for Tweets?)

I find value in reading both your posts and the comments that follow, but with all the Twitter mentions automatically posted as comments, it’s very painful to find what the real comments are…

Just a thought.

I have now re-read the article, and even though I caught a few more things (in retrospect, I did read everything but the conclusion fairly thoroughly the first time), I think I still would have posted the same comment as before. Consider the following excerpts:

> Scala has good, but compared to Clojure
> a rather basic [Java] integration.

…

> Scala isn’t tightly integrated on the
> API side – only with some in this
> context clumsy, unneeded Meta-Programming
> with impliciets. Scala promises Clojure
> like Collection integration with Java
> in the future – we’ll see.

In this context, I thought (and still think) that you were referring to the conversions between Scala and Java collections (currently in scala.collection.jcl). I agree(d) with you that this has been and will always be a sore point. My comment about Scala getting better collections in future was in reference to this:

> Some obvious reasons that speak for
> Clojure:
>
> …
> * STM, software transactional memory,
> an easy way to share data
> * Very clever immutable datastructures

The “very clever immutable data structures” point is listed as an advantage for Clojure. I was simply pointing out that advantage is going to be matched, if not superseded by Scala 2.8. Martin Odersky has stated that he intends Scala to have the fastest persistent collections of any JVM language.

> But as someone who is using Scala code
> from inside Java, “From the Java side
> things also do not look as nice, Scala
> classes and traits have lots of ugly
> named methods”

This comes out of the fact that Scala has very different idioms than Java. Symbolic method names, name/name_= vs get/set, etc. Scala also has some language features which don’t map nicely into Java (traits with implementations, singleton objects, etc). The point is that I don’t see how Clojure is any better in this respect. The only difference with Clojure is that you have to define the mapping into Java *explicitly*. It’s such a foreign syntax to create a class that you are almost forced to construct the API in a more Java-idiomatic fashion. You’re perfectly free to do this in Scala as well (keep your traits free of method implementations, use get/set instead of name/name_=, etc), the difference is that you don’t really feel the need most of the time.

I can see how Groovy has better Java integration, since its idioms are drawn directly from Java and its features map nicely into that language, but I just don’t understand the claim that *Clojure* has better Java integration than Scala.

“All Scala classes are Java classes. All Scala traits are Java interfaces.”

Yes, I did say “One can implement Java interfaces in Java, extend Java classes and vise versa.”

But as someone who is using Scala code from inside Java, “From the Java side things also do not look as nice, Scala classes and traits have lots of ugly named methods”

Perhaps you’re mainly using Scala from Scala and Java from Scala, so this might not apply to you.

About “As a side note, two of the advantages you listed for Clojure over Scala (STM and clever collections) are going to be rectified in upcoming Scala releases.” does differ how from “Scala promises Clojure like Collection integration with Java in the future – we’ll see.” (STM becoming part of Scala).

Daniel, I value your opinion very highly, but it looks like you have only scanned the post.

public int sumSeq(scala.Seq<Int> s) {
int sum = 0;
for (int i = 0; i < s.length(); i++) {
sum += s.apply(i);
}
return i;
}

Scala functions are also interfaces (no coercion necessary):

public <T> void foreach(scala.Seq<T> s, Function1<T, ?> f) {
s.foreach(f);
}

Additionally, your one example of using Java methods within Clojure didn’t actually have any Java methods whatsoever. That was all pure Clojure. A better example might be something like this:

(defn foreach [s f]
(.foreach s (f)))

Finally, you’re forgetting a *very* important aspect of Java integration: generating JVM classes and interfaces. Clojure’s integration with Java is very good, but the syntax to create a class is foreign and extremely unintuitive (doesn’t fit with the rest of the language at all). With Scala, creating a JVM class is as easy as:

class Foo { … }

All Scala classes are Java classes. All Scala traits are Java interfaces. This level of integration is impossible to overestimate. It means that you don’t need special magic to do things like extend Scala classes in Java, or implement Java interfaces in Scala. It all works together, seamlessly.

The one point of integration pain that I will give you is the fact that Scala’s collections are not in the same hierarchy as Java’s collections. Seeing as Java’s collections library is inherently broken though, I would consider that to be a “good thing” overall. It does mean that conversions are required whenever passing a Scala Map to a method expecting a Java Map, but those conversions are not difficult to create (they’re coming in Scala 2.8, and Jorge Ortiz has a very nice library which provides them now).

As a side note, two of the advantages you listed for Clojure over Scala (STM and clever collections) are going to be rectified in upcoming Scala releases. Believe it or not, Rich Hickey didn’t actually design Clojure’s collections completely from scratch, he adapted them from some work done by Phil Bagwell (he doesn’t hide this fact). Phil Bagwell just happens to work at EPFL; and yes, he is working on Scala’s collections library.

There are legitimate reasons to prefer Clojure over Scala. It’s much more concise, and the simple elegance of the language is very alluring. However, your arguments are unpersuasive.

nice post! I am just surprised you did not mention typing differences as pluses/minuses. I am guessing that for many that’s the real deal breaker (either way)

After some bad experiences, I’m not a proponent of polyglot anymore.It does not scale, with the slightest developer turnover you end up with noone understanding that Clojure code.

In our own company, we are currently using Java, Python, Ruby, C++ and PHP — and this is all within the sphere of one products ecosystem. We generally only recruit for Java/C++ developers since that is our primary area of focues, but I make it a point to ask about other languages during our hiring process and hope to spread that around to the rest of the team.

My experience led me to the same conclusion as yours regarding Java integration: In Clojure the integration is indeed clean and almost seamless. I especailly noticed that when I developed Waterfront – A light-weight clojure based IDE. Although the code uses many Swing APIs (incl. subclassing, customization, etc.) the process was surprisingly painless.

On the other hand, in Scala, the naming scheme of methods/classes makes Java integration much less straight forward.

On the other hand, no one can deny Scala’s impressive static typing capabilities. Seems like a great plus if you’re a static typing kind of guy.

Anyway, my bottom line is this: both languages make it a bit too easy for a programmer to shoot his own foot.

In Scala this is due to the type system: It does go an extra mile (compared to Java) but the road is still long and I am not sure an extra mile buys you that much when compared to the the increased mental burden of using these constructs.

In Clojure, the caveat is its flexibility. The number of choices the programmer already has, for almost any decision, is overwhelming. Again, this is essentially a good thing, but if the programmer is not careful enough he/she may find him/her self spending too much weighing the different options rather than getting things done.