python fanboy here:
"[python is] not as tuned to numerics as MATLAB": if you build numpy with ATLAS there is, in my experience, hardly ever any noticeable speed difference between numpy and MATLAB
The part about python not being as fast as Julia jumped at me. Wes McKinney's benchmarks show that python is faster than Julia for numerics: http://wesmckinney.com/blog/?p=475
EDIT: should not have said "python faster than Julia". They are comparable because the slow bits get done in BLAS anyway.
Cython is actually what is faster than Julia in Wes' comparison, not Python. Cython looks kinda, sorta like Python, but it is actually a static language with C-like types (but quite different syntax for those types), no polymorphism, and, afaict, ill-defined semantics. The best answer I seem to get about Cython's semantics is that Cython's semantics are whatever it does. I'm not alone in this complaint – Travis Oliphant expressed a similar concern at this year's SciPy (in this panel [http://www.youtube.com/watch?v=7i2vhoQY-K4], if I recall correctly), which is part of his motivation to work on Numba [https://github.com/numba/numba].
If you look at the comments on Wes' post, when I used the dot(x,y) function, which ships with Julia and uses a BLAS to compute the inner product just like the fastest "Python" version does, Julia is equally fast. That stands to reason – they're both just calling a BLAS.
Finally, that blog post is months old – since then Julia passed the milestone of being no slower than 2x C++ on its microbenchmarks suite [http://julialang.org/]. That's not a guarantee that all code is that fast, but most things we see can be pretty easily tweaked to get there (counterintuitively for those coming from Matlab, Python or R, usually by devectorizing the code rather than vectorizing it). And of course, there's a lot of room for improving Julia's performance, the compiler is still quite young and there are many optimizations that we haven't implemented. Basically, there's nothing but work standing in the way of reaching C or Fortran's speed across the board.
If the performance comes down to BLAS, then language speed benchmarks are moot. Saying one language is faster than another becomes disingenuous.
Fully agreed. That's why comparing NumPy calling BLAS to Julia calling BLAS is a silly exercise. Comparing NumPy calling BLAS to a summation loop written in pure Julia goes beyond silly to just unreasonable, but that's what the blog post does.
The highlight is
numpy: (x * y).sum() => 41.1 ms
julia: inner(x,y) => 37.4 ms
julia: x*y => 19.5 ms
cython: inner(x,y) => 13.8 ms
The numpy and Julia versions are much easier to write and run.
Disclaimers: I've never written or built cython code before just now, and I think Julia is the coolest.
EDIT: whoops, missed the most important one (inner() written in pure Julia). Added it. Any thoughts on why inner() in Julia isn't faster?
This would be a nice resource for newcomers with a language bent, and also as a building block for your Google Summer of Code applications ;)
Python/Octave/R are free, last I checked.