The Speed of Julia

02 — Multiple Dispatch

Functions that specialise on all argument types

Julia's most distinctive feature: a function can have many methods, and the most specific one is called based on the types of all arguments. This isn't just method overloading — it's a foundation for extensible, composable libraries.

abstract type Animal end
struct Dog <: Animal; name::String; end
struct Cat <: Animal; name::String; end

# Different behaviour for different combinations of types
interact(a::Dog, b::Dog) = "$(a.name) and $(b.name) play fetch!"
interact(a::Cat, b::Cat) = "$(a.name) ignores $(b.name)."
interact(a::Dog, b::Cat) = "$(a.name) chases $(b.name)!"
interact(a::Cat, b::Dog) = "$(b.name) hisses at $(a.name)."

interact(Dog("Rex"), Cat("Whiskers"))
# "Rex chases Whiskers!"

This isn't OOP method dispatch — both argument types determine which method runs. This makes operator overloading, unit systems, and automatic differentiation composable across independent packages.

03 — Broadcasting

Vectorise anything with a dot

Julia's broadcasting system lets you apply any function element-wise to arrays by adding a dot. You don't need a special vectorised version — just dot-apply the scalar function. The compiler fuses loops for you.

# A scalar function
clamp01(x) = max(0.0, min(1.0, x))

pixels = [-0.3, 0.5, 1.2, 0.8, -0.1]

# Dot-broadcasting applies it element-wise — no loop, no special version
clamped = clamp01.(pixels)  # [0.0, 0.5, 1.0, 0.8, 0.0]

# Works with any operator too
a = [1, 2, 3]; b = [4, 5, 6]
a .* b   # [4, 10, 18]  — elementwise multiply
a .^ 2   # [1, 4, 9]   — elementwise square

# @. broadcasts every operation in an expression
@. sin(a) + cos(b)  # fused into a single loop, no temps

Dot-broadcasting is syntactic sugar that compiles to a single fused loop. There's no runtime overhead from the abstraction — the code the compiler generates is identical to a hand-written loop.

04 — Macros

Code that writes code, the right way

Julia macros operate on the abstract syntax tree, transforming code before it compiles. Unlike C preprocessor macros, they're hygienic and operate on structured syntax. They're how Julia implements things like @time, @test, and automatic differentiation.

# @assert — readable test that shows the failing expression
@assert 2 + 2 == 4

# @show — prints variable name and value
x = 42
@show x  # prints: x = 42

# @benchmark from BenchmarkTools — statistical timing
@benchmark sort(rand(1000))

# Custom macro — transform code at parse time
macro swap(a, b)
    :(local tmp = $a; $a = $b; $b = tmp)
end

x, y = 1, 2
@swap x y
# x is now 2, y is now 1

The :(expression) syntax creates an AST node — a quoted expression. Macros receive and return these nodes, letting you rewrite syntax patterns before compilation.

05 — Unicode & Mathematics

Code that looks like the maths

Julia supports Unicode identifiers natively — you can write α, ∑, π, ∈ directly in your code. Mathematical algorithms read like their textbook descriptions, closing the gap between notation and implementation.

# Type directly from LaTeX: \alpha + Tab → α
function gaussian(x, μ, σ)
    (1 / (σ * √(2π))) * exp(-(x - μ)^2 / (2σ^2))
end

# Implicit multiplication: 2x means 2 * x
function circle_area(r)
    π * r^2  # π is a built-in constant
end

# ∈ from set theory works in loops
primes = [2, 3, 5, 7, 11]
for p ∈ primes
    println(p^2)
end

Implicit multiplication (2x) and Unicode identifiers mean that the formula from a research paper can be typed almost verbatim into Julia. The code is the maths.

06 — The Whole Picture

Why Julia is rising