- Just released episode 5 on expression threading (here, via @fulldisclojure) — Another great episode of this series of videos on the new features in Clojure 1.1. This one is about the ‘->’ and ‘->>’ threading macros.
- I’ve just released FleetDB, a schema-free database implemented in Clojure and optimized for agile development : http://fleetdb.org (here, via @mmcgrana) — Schema-free, in memory, declarative queries, JSON and a lot more goodies. The DB uses persistent data structures (a la Clojure) and hence reads can happen in parallel with writes. Writes are sequenced. Being a persistent data structure, once you get your version of the database, it will never change; this is therefore an interesting semantic difference with other more mainstream databases. Also provides an append-only log so you can rebuild the DB if the system fails. Can you say promising? I do :)
- cloduino – a Clojure API for the Firmata Protocol (here, via @grantmichaels) — Firmata is a protocol to control Arduino devices (should I say contraptions?) via the serial protocol. Now you can control Arduino devices via Clojure :) by downloading cloudino from here.
- Anatomy of a Flawed Clojure vs. Scala LOC Comparison (here, via @codemonkeyism) — This is a critique of @laujensen’s “Clojure vs. Ruby & Scala – Transient Newsgroups” article from last Dec 13rd, which has been heavily reposted lately. Lau’s article provides a non-scientific comparison of the cited programming languages based three straightforward implementations of the same program in Clojure, Scala and Ruby. There are two main measures used for this comparison: performance and lines of code (LOC). This critique states that comparing LOC is dangerous, as it is difficult to make it so that the results are meaningful and agreeable, and that comparing performance on JVM languages is also a difficult task. Let’s just say that the Scala camp was not happy with Lau’s article being retweeted…
- Clojure is as impure as Scala is (here, via @jneira) — this tweet refers to an article titled “Pragmatics of Impurity”, by @debasishg, which discusses the design decisions that some programming language authors make in order to have their languages be efficient and also leverage some of the benefits of purely functional languages. A great read!
- Clojure Contrib 1.0.0 RC1 available (here, via @fogus)
My main criticism was that @laujensen’s Clojure example did a different thing than the Scala one, it was missing timings, printlns and file checks. Secondly the Scala example wasn’t optimized, several lines of code reading the conent of a file could be replaced with only one line.
I think we can learn from LOC comparisons, but they should be done in a fair way, with the best examples from each language. Otherwise they are just FUD and a waste of everyones time.
Cheers
Stephan
http://www.codemonkeyism.com
Stephan, thanks for the clarification. LOC comparisons are always tricky and more often than not they are subject of heated debatable. Sometimes it is like comparing French with Chinese as the ideal for poetry. But I personally think that it is good to perform these kind of comparisons, like @Laujensen did, and also to point out at flaws in these comparisons when needed. At the end of the day, we all learn from all this dialogue!
Sometimes people get too carried away when they read these language comparison articles, only to focus on some numbers at the end of them and then start tweeting “Clojure is 25% faster than Scala and 50% shorter” (or whatever the tweet-storm was saying). It misses the whole point. Context in these kinds of articles is very important, and so is peer review.
Thanks for tuning in!