| layout | title |
|---|---|
default |
The Julia Language |
Julia is a high-level, high-performance dynamic programming language for numerical computing. It provides a sophisticated compiler, distributed parallel execution, numerical accuracy, and an extensive mathematical function library. Julia's Base library, largely written in Julia itself, also integrates mature, best-of-breed open source C and Fortran libraries for linear algebra, random number generation, signal processing, and string processing. In addition, the Julia developer community is contributing a number of external packages through Julia's built-in package manager at a rapid pace. IJulia, a collaboration between the Jupyter and Julia communities, provides a powerful browser-based graphical notebook interface to Julia.
Julia programs are organized around multiple dispatch, which allows built-in and user-defined functions to be overloaded for different combinations of argument types. For a more in-depth discussion of the rationale and advantages of Julia over other systems, see the following highlights or read the introduction in the online manual.
JuliaCon 2017, the annual conference on Julia, was held from June 20th to June 24th at the University of California, Berkeley. Below is a random video from our YouTube playlist of the talks. Click on the playlist icon to check out the other videos.
{% include juliacon-player-2017.html %}
- Multiple dispatch: providing the ability to define function behavior across many combinations of argument types
- Dynamic type system: types for documentation, optimization, and dispatch
- Good performance, approaching that of statically-compiled languages like C
- Built-in package manager
- Lisp-like macros and other metaprogramming facilities
- Call Python functions: use the PyCall package
- Call C functions directly: no wrappers or special APIs
- Powerful shell-like capabilities for managing other processes
- Designed for parallelism and distributed computation
- Coroutines: lightweight "green" threading
- User-defined types are as fast and compact as built-ins
- Automatic generation of efficient, specialized code for different argument types
- Elegant and extensible conversions and promotions for numeric and other types
- Efficient support for Unicode, including but not limited to UTF-8
- MIT licensed: free and open source
Julia's LLVM-based just-in-time (JIT) compiler combined with the language's design allow it to approach and often match the performance of C. To get a sense of the relative performance of Julia compared to other languages that can or could be used for numerical and scientific computing, we've written a small set of micro-benchmarks in a variety of languages: C, Fortran, Julia, Python, Matlab/Octave, R, JavaScript, Java, Lua, Mathematica. We encourage you to skim the code to get a sense for how easy or difficult it is to do numerical programming in each language.
Figure: Benchmark times relative to C (smaller is better, C performance = 1.0). Plot created with Gadfly and IJulia from this notebook. See the benchmarks page for more information.
To give a quick taste of what Julia looks like, here is the code used in the Mandelbrot and random matrix statistics benchmarks:
{% highlight julia %} function mandel(z) c = z maxiter = 80 for n = 1:maxiter if abs2(z) > 4 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 = [a b c d] Q = [a b; c d] v[i] = trace((P.'*P)^4) w[i] = trace((Q.'*Q)^4) end std(v)/mean(v), std(w)/mean(w) end {% endhighlight %}
The code above is quite clear, and should feel familiar to anyone who
has programmed in other mathematical languages. The Julia
implementation of randmatstat is considerably simpler than the
equivalent C
implementation,
without giving up much performance. Planned compiler optimizations
will close this performance gap in the future. By design, Julia
allows you to range from tight low-level loops, up to a high-level
programming style, while sacrificing some performance, but gaining the
ability to express complex algorithms easily. This continuous spectrum
of programming levels is a hallmark of the Julia approach to
programming and is very much an intentional feature of the language.
Julia does not impose any particular style of parallelism on the user. Instead, it provides a number of key building blocks for distributed computation, making it flexible enough to support a number of styles of parallelism, and allowing users to add more. The following simple example demonstrates how to count the number of heads in a large number of coin tosses in parallel.
{% highlight julia %} nheads = @parallel (+) for i = 1:100000000 rand(Bool) end {% endhighlight %}
This computation is automatically distributed across all available compute nodes, and the result, reduced by summation (+), is returned at the calling node.
Here is a screenshot of a web-based interactive IJulia Notebook session, using Gadfly. JuliaBox provides a way to run IJulia notebooks in your browser on Docker sandboxed containers provisioned on demand.
This paves the way for fully cloud-based operation, including data management, code editing and sharing, execution, debugging, collaboration, analysis, data exploration, and visualization. The eventual goal is to let people stop worrying about administering machines and managing data and get straight to the real problem.
Gadfly can produce various plots with various rendering backends in the browser (SVG, PDF, PNG and various other backends are also supported). Interactivity can be added to graphs and plots with the Interact.jl package. A small sampling of the capabilities of Gadfly is presented below.
The core of the Julia implementation is licensed under the MIT license. Various libraries used by the Julia environment include their own licenses such as the GPL, LGPL, and BSD (therefore the environment, which consists of the language, user interfaces, and libraries, is under the GPL). The language can be built as a shared library, so users can combine Julia with their own C/Fortran code or proprietary third-party libraries. Furthermore, Julia makes it simple to call external functions in C and Fortran shared libraries, without writing any wrapper code or even recompiling existing code. You can try calling external library functions directly from Julia's interactive prompt, getting immediate feedback. See LICENSE for the full terms of Julia's licensing.