The birth of Julia for parallel processing and cloud computing

Why create a Julia programming language?

In a word, because we thirst for knowledge, constant pursuit.

We have the core users of MATLAB, there are good at Lisp hackers, Pythonistas and rubyists experts also have a lot; In addition, there are some Perl Daniel, some developers used Mathematica before we had a little understanding of the fur. In other words, they understand more than just the fur, more than others, the development of R language. and C language for us is a deserted island.

We love these languages very much, they are so perfect and powerful. We have done a lot of research on scientific computing, machine science, data mining, large linear algebra and distributed parallel computing-it can be said that each project has its own advantages and even fear others. Any project will weigh the balance.

We are greedy, we want more.

We need an open source language that is recognized as licensed in the industry (based on license). We want this language to be as fast as C, and Ruby as energetic (dynamism). We need languages like Homoiconic, which have macros like Lisp, but also have obvious, familiar mathematical markers like MATLAB.

We want traditional programming languages to be as useful as Python, like R language for statistics, like Perl for string processing, as powerful as linear algebra matlab, and good at gluing programs like DOS commands. It seems easy to learn, but it's not easy to get hackers to be willing to pander to it. We want it to be interactive and capable of being compiled.

Run as fast as C?

Wanted to provide: the Hadoop distributed core, because there are no Java and XML thousand-byte boilerplate files, unable to filter through gigabytes of log files on hundreds of machines to find bugs.

Deny operational permissions that are complicated. We want to write a simple hierarchical Loop (code) that can be compiled using rigorous machine code from a register on a single core CPU. For example, write a a*b code, and then use 1000 computers for 1000 computations, these computers put together is a huge matrix product.

When we don't like the type, we never mention it. When dynamic functions are needed, generic programming is needed to write the algorithm and apply it to the type. To find the best way to select parameters from multiple angles and effectively for all functions, and to define the common characteristics of different types in dozens of ways, we simply want to make the language simpler and cleaner.

All these requirements don't look too much, do they?

About 2.5 ago, began to develop the language, then is not a full version, with the release time is coming, the final 1.0 version of brewing and life-we named it Julia.

The 1.0 edition basically 90% achieves our "unreasonable" request. And now it is up to you to put forward "unreasonable" requirements and to further transform it. Therefore, if you are a proactive, thirsty programmer, you might as well try.

The new darling of programming language--julia birth

Julia is a new high-performance dynamic advanced programming language. syntax is similar to other programming languages and is easy for other language users to learn. Julia has a rich library of functions, providing digital precision, refined growth device (sophisticated amplifier) and distributed parallel operation. Most libraries, such as core function libraries, are written by Julia, but they also use mature C and Fortran libraries to deal with linear algebra, random number generation, and string processing. The Julia language can define functions and then overload them based on the user-defined combination of parameter types.

JIT High Performance compiler

The JIT (Just-in-Time) Just-in-time compiler used by Julia effectively improves its efficiency and, in some places, can even compare to C and C + +.

Below the standard test procedure to test its efficiency, you can compare the operating efficiency of each language.

Note: The operating environment is a MacBook Pro,2.53ghz,intel Core2 Duo CPU and 8G 1066MHZ,DDR3 memory.

The only C + + run time in the table above is absolute time, others are relative to C + +, and the smaller the number, the less time it takes. Except for a few Tests Julia was defeated by Matlab and JavaScript, Julia beat other advanced languages, even on Pi summation, successfully defeated C + + with 25% advantage. By using the Intel Core Math Library (MKL), Matlabs has a slight advantage in matrix multiplication, but Julia with the MKL authorization can also use the Intel MKL Library, although the default open source Blas library performance is good.

This test table is based on compiler performance analysis of a series of common code patterns. For example: string parsing, function call/callback, sorting and numerical looping, generating random numbers and array operations, and so on.

Julia overcame the difficulty of the high-level language: the scalar arithmetic cycle (which is reflected in pi summation). ）。 Matlab floating-point arithmetic JIT and V8 JS engine also handled very well. However, JS does not support lapack and other linear algebraic libraries lead to low performance in matrix operations, while Julia has a number of methods to eliminate the load (overhead), so that it can easily support any function library.

The Julia Code of Matrix statistics is not as good as C + + but it is much simpler. However, it may become a problem in the future to standardize and compile too casually.

Julia code example:

Born for parallel processing and cloud computing

Julia provides many key modules for distributed computing, making it more flexible to support multiple parallel processing.

Although still an early version, Julia already supports cloud computing. Here's a screenshot of the interactive Julia session:

Julia will provide more complete performance support for cloud computing operations, such as sharing and editing, including data management, data mining, and visualization operations. It also allows users to manipulate large data types without being concerned with data manipulation behavior.

Free, open source and library friendly

Tjulia's core code follows the MIT protocol, while other libraries follow GPL/LGPL/BSD protocols. The user can also conveniently use Julia as a core feature shared library with C/fortran code.