Such a program that wasn’t written the way the language designers intended is not a fair comparison at all.

For example, here’s some code that not only reads all the text from a file, it also skips comments that start with a #. It’s pretty damn easy to understand, and it’s concise:

val text = Source.fromFile(“somefile.dat”)
.getLines
.filterNot(_.startsWith(“#”))
.mkString

But seriuosly, I think Clojure will be compulsorily less verbose than Scala, as Scala is a statically typed language and Clojure isn’t, so you’d sometimes need explicit type annotations. Moreover, Scala has all the OO-bagage and Clojure doesn’t. But all that isn’t relevant when comparing languages, this are 2 diffrent ideas about how to leverage Java infrastructure and they are both interesting.

Which said, I like Clojure better…

I also think LOCs are important. I hope we will learn more about different languages, apply more scientific rigor and learn how to interpret facts and results (e.g. how less lines of code lead – perhaps – to denser lines which are – perhaps – less readable. Though K advocates claim to just “sense” the code from looking at it).

But this would start with an honest will to find the best example in each language, not makeing the “other” language look delibertly worse.

And I’d call that FUD – it seems I have lower standards than you :-)

I agree the comparison is flawed. However I am not sure if it tantamounts to FUD. Perhaps in my mind the threshold for getting that moniker is a little higher. I suspect I would look for some clear, deliberate sales pitch or alternatively an unnecessarily defensive approach or picking on some really silly unimportant issues for me to feel comfortable with calling it FUD.

I did look up other articles and there’s some evidence of similar flaws in there as well. eg. Python vs Clojure – Reloaded. If you take a look at the #3 Top Rank per group example, it talks of 12 lines of python to 6 lines of clojure, yet another link in the comments http://gist.github.com/214369 shows an alternative implementation in 6 lines with excellent readability. Just to push the envelope I was able to implement exactly the same solution in exactly 1 line with atrocious readability.

I think some of the programming styles require a substantial tradeoffs between readibility and brevity. Moreover writing concise code with high readability may often require a substantial skill and even awareness of the language libraries and ecosystem, a capability the person conducting the analysis may not be equally blessed with in various languages.

I think LOCs are important. Perhaps one needs to be very careful about using results of such comparisons, unless the results are consistently observed across many different code samples and across different programmers.

scala.io.Source.fromFile(file).mkString

but got java.nio.BufferUnderflowExceptions, I guess due to Source.DefaultBufSize=2048 maybe? But specifying the character encoding does seem to work:

scala.io.Source.fromFile(file, “ISO-8859-1″).mkString

So knock a few more off the Scala LoC count. :)

Lau hasn’t been so restricted,

“(note: spit and slurp* are from contrib.duck-streams and str-join are from str-utils)”

http://blogs.sourceallies.com/2009/12/word-counts-example-in-ruby-and-scala/comment-page-1/#comment-280

Further improvements are always welcome! :)

The unfortunate side-effect (hah!) of “vs” articles is that they don’t reflect well on the Clojure community, as someone is bound to take them the wrong way.

As a Clojure person myself, I believe Clojure can stand on its own, and I hope it will, without any need to downplay the merits of other languages. I’m sure most of the community would agree with me.

http://blog.fogus.me/2010/01/04/comparing-lines-of-code-scala-and-clojure-fud-version/

-m