Julia Cheat Sheet

Syntax lookup for people analysing simulations in Julia. It assumes you can already program, and answers "how do I write that here", not "what is a loop".

Two pages nearby cover what this one deliberately leaves out: Essential Packages for what to install, and Resources & Community for tutorials, books and where to ask. For performance in the context of real analysis, see Julia for Simulation Analysis and Multi-threading.

[base] ships with Julia. [mera] is already a Mera dependency, so using Mera is enough. [extra] needs ] add first.

1. Install and start

Use Juliaup. It manages Julia versions the way pyenv or conda manages Python.

2. The REPL

Four modes, reached by typing one character at an empty prompt. Backspace returns you to Julia mode.

Useful anywhere:

3. Reproducible environments

An environment records exact package versions, so a result can be reproduced later or on another machine.

] activate .          # in your project folder, creates a local environment
] add Mera CairoMakie
] instantiate         # on another machine: installs exactly what Project/Manifest record

Project.toml lists what you asked for, Manifest.toml records the exact versions resolved. Commit both. For random numbers, using Random; Random.seed!(1234).

Mera writes the environment into the files it saves, so a stored result can say what produced it: see Provenance.

4. Coming from another language

The five that catch everyone

Python

MATLAB

IDL

5. Arrays and indexing

Indices start at 1 and ranges include their last element.

Arrays are stored column first, as in Fortran and MATLAB. The first index should be the innermost loop.

6. Linear algebra

using LinearAlgebra for everything below the first two rows.

Prefer A \ b over inv(A) * b: it is faster and more accurate.

7. Statistics and fitting

using LsqFit
model(x, p) = @. p[1] * exp(-p[2] * x)
f = curve_fit(model, xdata, ydata, [1.0, 1.0])
f.param

Mera bins simulation data for you: see profile rather than histogramming by hand.

8. Tables

DataFrames.jl is the equivalent of pandas, CSV.jl reads and writes the files.

9. Units and uncertainties

Mera does not use Unitful. It carries its own scale factors, so you ask for a unit by name: getvar(gas, :rho, :nH). See Units and constants.

10. Control flow

Blocks close with end.

if x > 0
    println("positive")
elseif x < 0
    println("negative")
else
    println("zero")
end

for i in 1:10
    println(i)
end

for x in arr           # over values
    println(x)
end

i = 1
while i <= 10
    i += 1
end

for i in eachindex(A) is the safe way to walk an array: it works for any index type and never goes out of bounds.

11. Functions and multiple dispatch

A function can have many methods. Julia picks one from the types of all the arguments, not just the first. This is the language's central idea, and it is what lets Mera give getvar or projection the same name for hydro, particle and clump data.

area(r::Real)            = π * r^2          # a circle
area(w::Real, h::Real)   = w * h            # a rectangle

abstract type Shape end
struct Circle    <: Shape; r; end
struct Rectangle <: Shape; w; h; end

area(c::Circle)    = π * c.r^2
area(r::Rectangle) = r.w * r.h

areas = area.([Circle(1), Rectangle(2, 3)])   # the dot maps over the array

Structs hold data, methods live outside them, and there is no obj.method(). Only abstract types can be inherited from.

Functions are values: pass them, return them, write them inline.

map(sin, 0:0.1:π)
filter(isodd, 1:10)
reduce(+, 1:100)
f = x -> x^2 + 1        # anonymous
g(x) = x^2 + 1          # named, same thing

12. Writing fast Julia

Five rules cover most of it.

1. Put code in functions. Code at the top level of the REPL or a script cannot be optimised, because a global's type can change at any moment. This one rule is usually worth more than the other four together.
2. Keep types concrete and stable. Vector{Float64}, not Vector{Any}, and do not reassign a variable to a different type inside a function.
3. Pre-allocate. Build the output array once outside the loop, not on every pass.
4. Broadcast or loop, both are fast. Julia loops compile to the same machine code as C, so an explicit loop needs no vectorising to be quick. Write whichever reads better.
5. Measure before you change anything. @btime from BenchmarkTools, then @profview when you need to know where the time goes.

function square_all!(y, x)
    @inbounds for i in eachindex(x)
        y[i] = x[i]^2
    end
end

y = similar(x)
square_all!(y, x)

Loop the first index innermost, because that is how the memory is laid out:

function fill_sum!(A)
    @inbounds for j in axes(A, 2)      # columns outer
        for i in axes(A, 1)            # rows inner, fastest moving
            A[i, j] = i + j
        end
    end
end

Two things dominate real analysis work and have their own pages: compile-time latency and memory discipline, and threading.

Beyond threads, Julia also offers Distributed (pmap, @distributed) for several processes, MPI.jl for clusters, and CUDA.jl for GPUs. Mera itself is threaded, not distributed.

13. Plotting

Makie is the current standard. Pick a backend by which package you load.

using CairoMakie

fig = Figure(size=(600, 450))
ax  = Axis(fig[1, 1], xlabel="x [kpc]", ylabel="y [kpc]")
lines!(ax, 1:10, rand(10))
scatter!(ax, 1:10, rand(10))
fig

The pattern is: build a Figure, put an Axis in a grid cell, then draw into it. Plot functions ending in ! add to an existing axis, those without create a new figure.

PyPlot.jl gives a matplotlib interface if you prefer one.

14. Files in and out

Save named variables, not a whole workspace. JLD2, HDF5 and CSV are Mera dependencies, so they need no install. Mera's own format is JLD2: see Export and import.

15. Calling other languages

The other direction works too: JuliaCall from Python or R, jl_init() from C, and PackageCompiler.jl to build a standalone executable.

16. Where to go next

• Essential Packages, what to install and in what order
• Resources & Community, tutorials, books, and where to ask
• Julia for Simulation Analysis, the parts that matter for this kind of work
• Switching to Mera, if you are arriving from another analysis tool
• The Julia manual for anything this page compressed too far