1. Speed in iterative algorithms.

2. (Almost) painless concurrency.

3. Symbolic programming right in the language (think of SymPy built in the language).

4. Closeness to Matlab (which makes it easy to translate existing code).

In general, people tend to port to Julia algorithms that were originally written in Matlab or C++ (with the conciseness of first and speed of the second). For example, I made several attempts to translate Matlab/C++ code of active appearance models to NumPy, but succeeded only with Julia [1]. Another example - Mocha.jl [2] - is a port of Caffe deep learning framework (written in C++ with a wrapper in Python) into a pure Julia, which it easy both to use and modify.

So if you just use existing libraries, there's probably no big difference what to use. But if you actively write new libraries, at least give Julia a try.

[1]: https://github.com/dfdx/ActiveAppearanceModels.jl

[2]: https://github.com/pluskid/Mocha.jl

I used to (almost) exclusively use Python and didn't like that I had to go bath and forth with Cython to make my models fast. Earlier this year I ported some of my code to Julia and feel more productive because of it. I feel like it's easier for me to implement new non-trivial improvements to my models than it was before.

For what it's worth I still stick with Python for computer vision applications. I mostly use Julia for timeseries models (e.g. Semi Markov CRFs) where it's harder to vectorize everything.

If I were restart again I'm not sure if I would suggest going the Julia route. I know there are alternatives like Numba that enable you write efficient code with minimal effort. Overall I like Julia as a language but there are a lot of little issues due to it being a new language.

The big reason, performance. On a good day I've seen 5-10x performance improvements over python/numpy for real life code. Of course on bad days I've seen 2x slowdowns, but I'm reasonably confident that within another couple of releases they'll consistently beat python/numpy. Also the Julia syntax is a bit nicer then numpy in my opinion, but that is secondary.

Of course there is both pypy and numba trying to improve the performance on the python side of things.

Also numpy code looks terribly ugly for numerical computing, when compared with julia (looks like matlab, but the language doesn't suck like matlab.)

julia seems like they're chasing the holy grail: a language that's pleasant to do math in (python is distinctly not this), nice to prototype with, and robust enough and fast enough for production work. I would be delighted if they succeed.

In instance, a lot of new research on statistics is done in R, mainly because is the standard in the industry/academy. If you want to use some new algorith you just readed about on a Journal, it will be implemented almost surely in R.

Julia have been trending for a couple years, and now a lot of researchers publish both R and Julia packages, it seems that in the future most research will be done in Julia.

TL;DR: If you just need basic statistics, interval estimation and alike, then you can use whatever you want, but if you want to use state-of-the-art algorithms. R/Julia are the tools.