
Crystal vs. Node.js vs. Golang vs. Julia vs. Rust vs. LuaJIT vs. C Fibonacci Benchmark - seraum
http://blog.seraum.com/crystal-lang-vs-nodejs-vs-golang-vs-julia-vs-rust-vs-luajit-vs-c-fibonacci-benchmark
======
leovonl
If you compile the Rust example with optimization (-O) it just throws the
result away, which gives the ~0.030 time chrisdouay found.

However, if you add a println!() around it, it has to calculate the result.
Here's the running time:

    
    
        > time ./fib
        1134903170
    
        real    0m2.242s
        user    0m2.240s
        sys     0m0.000s
    

I tried the C example as well (with -O2) and found this:

    
    
        > time ./cfib
        1134903170
    
        real    0m4.671s
        user    0m4.670s
        sys     0m0.000s
    
    

So.. which one is faster again?

This "comparison" unfortunately seems too naïve to not be on purpose - no
analysis, no real discussion, not even some reasoning about the defaults and
why the big difference in numbers. It seems to be just looking for
views/comments (even if negative) without any intention to produce real
content. What worries me are the ones that will take this for a real benchmark
and just "share on facebook" and spread more disinformation.

------
steveklabnik
How was this stuff compiled? There's no way to reproduce these numbers without
compiler flags, at least.

For example, with "rustc fib.rs", I get 10 seconds as a runtime. With "rustc
-O fib.rs", to turn on optimizations, I get 0.034s. This makes me pretty sure
that they did not turn on optimizations, which means the Rust numbers are very
misleading, and possibly, the other languages as well.

~~~
chrisdouay
I get 0.034s => this means the compiler run the code and puts directly the
result in the binary file. So, when you run the binary, it only
println(result)

------
rubyfan
I don't love the conclusion, a single Fibonacci benchmark is fairly light
evidence to blanket state Crystal is as fast as C. It's also fairly toothless
on comparison of other languages.

------
FourierT-form
_COUGH_ Tail recursion _COUGH_

