Julia

For the past twenty years, researchers using scientific computing have lived with a constraint that slows down their work: they must choose between a language that’s easy to use for testing ideas and a language that runs fast for producing results. When prototyping, they use Python or MATLAB. But as soon as serious calculations are needed, they start over in C++ or Fortran. This constant back-and-forth between two languages wastes time and complicates projects unnecessarily.

This is the problem that Jeff Bezanson, Alan Edelman, Stefan Karpinski, and Viral Shah decided to tackle in 2009 at MIT. They wanted to create a language that would combine the simplicity of dynamic languages with the speed of compiled languages. A bold bet, since these two qualities seem inherently contradictory.

The first version of Julia was released in 2013. From the beginning, the language targeted scientific computing with an architecture designed for operations on multidimensional arrays, in the manner of Fortran. The engine relies on LLVM, which generates machine code adapted to different hardware architectures. Julia compiles code on the fly, as it executes. This just-in-time compilation reconciles two worlds previously thought separate: the responsiveness of an interpreted language and the speed of a compiled program.

Julia’s originality lies primarily in its multiple dispatch system. Unlike traditional object-oriented languages where a method depends on the type of a single object, Julia selects the right function based on the types of all arguments. This mechanism makes code much more flexible and facilitates the composition of libraries that weren’t designed together. The language also integrates powerful macros, native parallel computing, and seamless interaction with existing C or Fortran code.

The community took shape. In 2014, the first JuliaCon took place, quickly becoming an annual event. Three years later, the registry already contained over 1,000 packages. Major companies began taking interest: Aviva and the Federal Reserve Bank of New York in finance, Pfizer, Moderna, and AstraZeneca in pharmaceuticals, ASML for semiconductors.

The performance is impressive. Benchmarks show that certain mathematical functions written in pure Julia run faster than their optimized equivalents in C or Fortran. The implementation of the inverse error function beats MATLAB’s by a factor of 3 to 4, and SciPy’s by 2 to 3. This speed comes from metaprogramming and code generation techniques that Julia exploits naturally, where a low-level language would require contortions.

The name of the Jupyter environment recalls the connection with Julia (along with Python and R). These notebooks, which mix code, results, graphics, and text, fit well with the needs of teaching and reproducible research. MIT and other universities now use it for their numerical computing courses.

Julia runs on various architectures: ARM processors and GPUs. The integrated package manager simplifies dependency management and ensures environment reproducibility. Tools automate the creation of bridges to C++ libraries, providing access to a considerable software heritage.

In 2022, Julia tackled large-scale scientific projects. The Climate Modeling Alliance uses it for climate modeling, the Celeste project for astronomical image processing, and high-energy physics teams for data analysis. These applications demonstrate that the language performs well on complex and massive calculations without sacrificing code readability.

Development follows a classic open-source approach, with code on GitHub. Between 2009 and 2017, over 40,000 commits accumulated. Contributions go through strict review that maintains quality. Comprehensive documentation and online tutorials help newcomers get into the language without too much difficulty.

The initial design choices proved sound for following the evolution of scientific computing. The team continues to improve compilation times, automatically optimize code, and support new architectures. The common thread remains the same: a single language that combines ease of use and performance.

Julia shows that programming languages can be rethought to transform scientific practices. By elegantly solving the two-language problem, it changed what we expect from a computational tool: productivity without compromise on speed.