Comments on: Clojure vs Ruby, Part I

By: ajay

ajay — Thu, 17 Dec 2009 18:41:35 +0000

One of the nice features that I like a lot is the memoize in Clojure. That makes Dynamic Programming so easy! I no longer have to manually create an array or Hashmap and then fill it in my algorithm. It is automagically taken care off!

It think that is important to consider memoization too, because memoization in C or Ruby requires a lot additional work.

By: Robert

Robert — Thu, 10 Dec 2009 07:24:51 +0000

Googles Go:
time ./8.out
165580141
./8.out 4,39s user 0,00s system 90% cpu 4,842 total

—–8<——–
1 package main
2 import "fmt";
3 func fib(n int) int {
4 if(n<=1){ return 1; }
5 return fib(n-1) + fib(n-2);
6 }
7 func main() {
8 fmt.Println(fib(40));
9 }
—–8<——–

By: Sean Purser-Haskell

Sean Purser-Haskell — Fri, 02 Oct 2009 20:27:04 +0000

Is this just a single run of each? Certainly in the case of the JVM I would expect to see significant speedup on subsequent runs (due to JIT compilation). In general a single run doesn’t tell the whole story.

By: Martin

Martin — Sun, 24 May 2009 21:44:20 +0000

Sam: Sure that is not a cached result? I get “Elapsed time: 0.272 msecs” for the first run and and approx 0.04 for subsequent runs.

By: Sam

Sam — Sun, 24 May 2009 14:07:10 +0000

I know you’re using a naive fib algorithm for a benchmark, but I just have to post my favorite clojure fibonacci sequence algorithm – it’s very fast and clojure-idiomatic. I didn’t write it, but used it to learn about lazy sequences in clojure.

(def fibonacci-seq
(lazy-cat [0 1] (map + fibonacci-seq (rest fibonacci-seq))))

user=> (time (nth fibonacci-seq 40))
“Elapsed time: 0.045 msecs”
102334155

By: Josh

Josh — Sun, 28 Dec 2008 05:05:26 +0000

The regular Clojure fib takes about 6.5s to do fib(35) on my machine. Using the ‘unchecked’ version halves that time. However, Scala runs fib(35) in approx. 212ms! What the heck is going on?

By: Mike Perham

Mike Perham — Thu, 25 Dec 2008 03:55:24 +0000

I chose to test each environment as default because I don’t pretend to be an expert in each. Isaac wins; his gcc options made a significant improvement:

C (gcc 4.2, -O3 -pipe -Wall -fomit-frame-pointer) 0.9 seconds

Thanks to everyone for your comments.

By: anon

anon — Wed, 24 Dec 2008 15:26:07 +0000

And your point is what, again?

octave:6> tic;(((1+sqrt(5))/2)**40 – ((1-sqrt(5))/2)**40)/sqrt(5);toc

Elapsed time is 0.000118971 seconds.

A better algorithm beats a better implementation almost any day.

By: Riaan Minne

Riaan Minne — Tue, 23 Dec 2008 10:10:17 +0000

Yea throw Scala into the mix..!

By: Ivan

Ivan — Sat, 20 Dec 2008 09:13:17 +0000

Adam, tail recursion won’t help with this benchmark, because this version of “fib” is not tail recursive.