If you really want to crunch numbers, I highly recommend Haskell. It falls short of Python in terms of libraries and by some accounts, readability, but it is substantially faster and excels at number crunching. I find it easier to express number crunching in functional rather than object-oriented style programming. Python has lambdas, but usually theres a more pythonic way to express something in Python. Although I must say, I find Haskell's list comprehension syntax slightly more elegant.

http://tryhaskell.org/

edit: I take it back about Haskell's list comprehension syntax. At the end of the day they're both great. Haskell's syntax just feels like reading set theory notation.

I'm not sure I believe you that Haskell is faster than Python. In general, most of your python operations will be raw matrix operations handled by blas/lapack/etc.

While Python's functional programming constructs leave a lot to be desired, they are usually good enough for numerical work. Instead of using reduce(...) to sum an array and having it compile down properly, you can just use arr.sum(), which is implemented in C by numpy anyway.

I love Haskell (and want it to beat Python), but at this point, Python is the clear winner for numerical work. Libraries matter more than language in this case (as matlab demonstrates).

I think you're right that Python will be faster than Haskell when it's calling blas/lapack for matrix operations.

Found this old comment relevant: http://lambda-the-ultimate.org/node/2720#comment-40694

I never programmed in haskell, but I did in clojure and I must say that functional style and number crunching fit really nice. Said that, I am not sure you can beat things like numpy or pandas when it comes to complex/big datasets. I looked around in the haskell world and it seems that to do the same as, say, in pandas you need to write a lot of things yourself and you can't rely on the same superb documentation.

But I will be really happy to be proven wrong. I really think lots of things would be easier in Haskell.

And there's also a great and growing set of tools for numerical and data related computation.

Scratch that, the current ongoing dev and research work that is making its way onto the haskell hackage is both astonishing and often superlative code. The libs released in the past month and the ones I know will be made available over the coming months... It's just great work! (I'm biased owing To using some of these tools for fun and profit :-). )

That aside, Pandas is a really nice piece of engineering that really works. It's a good role model for other libs, even when restricted to just its data frame part

Just curious, could you link to some of these libraries? Genuinely curious here (I really want Haskell to win).

Newest ones are: meta-par (a work stealing scheduler as a library that can shuttle work btwn CPU,gpu, and distributing across other machines.) Pending one you can find online: distributed haskell (the production version is on github, and there's a proof of concept package on hackage called remote) Things that have been around a bit that have ongoin work: repa, dph, accelerate, and to some extent hmatrix.

There's a few other projects that aren't quite public yet going on that should make it possible to do some of the standard things you might want like a nice staticly typed fast data frame (which is going to look at pandas as an initial role model) and some other parts of the data analysis flow.

and on the DataFrame front, look to https://github.com/cartazio/HasCol in a few days - week for a prealpha/alpha look at what shall be the kernel of the haskell story for doing a nice data frame. :)

Most number crunching is definitely functional; however, most programming (even in science) is about all the window dressing before you get to the actual heart of the number crunching. For those tasks, an imperative syntax is usually more approachable for those without formal CS backgrounds (especially if they know a little C, FORTRAN, or MATLAB). This is why Python is so popular with the scientific computing crowd.

Thanks for the advice :)

I haven't programmed in any substantial quantity or quality since 2004, so I'll start with a more approachable language (Python), but I'll definitely keep an open mind.

Do keep an open mind, but bear in mind that Haskell is a different style of programming all together and there are libraries to speed number crunching in Python (NumPy).

If you want to crunch numbers, you should keep an eye on the Julia Language (http://julialang.org/). It's "a high-level, high-performance dynamic programming language for technical computing". Seems to math friendly with a nice syntax.