Book 14 · Programming LanguagesPage 16 of 33

Julia

Pronunciation: JOO-lee-uh

Updated October 3, 20262 min read

In short

Julia is a high-level, dynamically typed language for scientific and numerical computing, designed to be as easy to write as Python and as fast as C.

What is Julia?

Julia was created at MIT by Jeff Bezanson, Stefan Karpinski, Viral Shah and Alan Edelman, announced publicly in 2012, and reached version 1.0 in 2018. Its creators wanted to solve the two-language problem: researchers often prototype in a slow, friendly language such as Python or MATLAB and then rewrite the hot parts in C or Fortran for speed.

Julia code is compiled to machine code just in time through LLVM, specialized for the types it is called with, so a plain loop runs at speeds close to C without special tricks. The syntax is clean and math-friendly, supports Unicode symbols such as α and √, and arrays start at index 1, like MATLAB and Fortran.

Its central idea is multiple dispatch: a function can have many methods, and Julia picks one based on the types of all its arguments. This lets packages from different authors work together naturally. Julia is used for differential equations, optimization, climate modeling, finance and machine learning, with packages such as DifferentialEquations.jl, JuMP and Flux.

A common misconception is that Julia is always faster than Python. Running code for the first time involves compilation, which makes startup and first calls slow, a delay known as time to first plot that newer versions have greatly reduced. Its ecosystem and community are also much smaller than Python's.

Key takeaways

Julia is a fast, dynamic language for scientific and numerical computing.
It was announced in 2012 and reached version 1.0 in 2018.
JIT compilation through LLVM gives speed close to C.
Multiple dispatch chooses methods based on all argument types.
First runs are slow while compiling, and the ecosystem is smaller than Python's.

Example

Multiple dispatch and fast loopsjulia

# One function, methods chosen by the types of *all* arguments
area(r::Real) = π * r^2                 # circle
area(w::Real, h::Real) = w * h          # rectangle

struct Square; side::Float64; end
area(s::Square) = s.side^2

println(area(2.0), " ", area(3, 4), " ", area(Square(5)))

# A plain loop compiles to fast machine code
function sum_of_squares(xs)
    total = 0.0
    for x in xs
        total += x^2
    end
    return total
end

sum_of_squares(rand(10_000_000))

Readers ask

Julia or Python for data science?

Python has a far larger ecosystem, more tutorials and more jobs. Julia shines when you need custom numerical code to run fast without switching to C, such as simulations and differential equations.

What is multiple dispatch?

Choosing which version of a function to run based on the types of all of its arguments, not only the first one as in most object-oriented languages. It is Julia's main way of organizing code.

Is Julia compiled or interpreted?

Compiled, just in time. Each function is compiled to machine code the first time it runs with particular argument types, which is why later calls are fast and the first one is slower.