Why we created Julia, the new YAP for technical computing

In short, because we are greedy.

We are advanced users of Matlab. Some of us are Lisp hackers. Some pythonists, other rubists, there are still Perl hackers. There are those among us who used Mathematica before his hair began to grow. There are those who still have not grown up. We built more graphs on R than any sane person is capable of. C is the language we would have taken on a desert island.

We love all these languages; they are beautiful and powerful. For the work that we do - scientific computing, machine learning, data mining, large-scale linear algebra, distributed and parallel computing - each is ideally suited in a certain aspect, but terrible in others. Each of them is a compromise.
')
We are greedy: we want more.

We want an open source language under a free license. We want the speed of C and the dynamism of Ruby. We want a language with code and data equivalence, with real macros as in Lisp, but with obvious, familiar mathematical notations, like in Matlab. We want a convenient tool for generic programming like Python, easy for statistics like R, natural string handling like Perl, powerful linear algebra like Matlab, good gluing of programs like a shell. Something absolutely simple to learn, but at the same time making most of the serious hackers happy. We want it interactive and we want it compiled.

(We mentioned that it should be fast, like C?)

While we continue to demand, add something else that provides Hadoop distributed performance — without kilobytes of Java and XML boilerplate code; without the need to wade through gigabytes of logs on hundreds of machines to catch bugs. We want power without shells of impassable complexity. We want to write simple scalar cycles that are compiled into compact machine code using only registers on a single CPU. We want to write A * B and run a thousand processes on a thousand machines, together computing a huge matrix.

We do not want to mention data types unnecessarily. But if we need polymorphic functions, we want to use generalized programming to write the algorithm once and apply it to an infinite type lattice; we want to use multiple dispatching to efficiently select the best method for all function arguments, from dozens of method descriptions, providing common functionality among radically different types. Despite all this power, we want the language to be simple and clear.

We don't ask too much, right?

Even though we are aware of our inappropriate greed, we still want it all. About two and a half years ago, we began to create the language of our dreams. It's not finished yet, but it's time for release 1.0 — the programming language we created is called Julia . She already satisfies 90% of our coarse requests, and now she needs even more coarse requests from other people to develop further. So if you are a greedy, reckless, demanding programmer, you should try.


^{Microbenchmark on a MacBook Pro with a 2.53 GHz Intel Core 2 Duo CPU and 8 GB DDR3 RAM 1066 MHz, for C ++, the absolute execution time is specified in milliseconds, the rest relative to C ++ (less is better)}

Sources of all benchmarks

Julia code example for Mandelbrot set and random matrix statistics

function mandel(z) c = z maxiter = 80 for n = 1:maxiter if abs(z) > 2 return n-1 end z = z^2 + c end return maxiter end function randmatstat(t) n = 5 v = zeros(t) w = zeros(t) for i = 1:t a = randn(n,n) b = randn(n,n) c = randn(n,n) d = randn(n,n) P = [abcd] Q = [ab; cd] v[i] = trace((P.'*P)^4) w[i] = trace((Q.'*Q)^4) end std(v)/mean(v), std(w)/mean(w) end