Julia, the programming language

2.1 Intros

In order of increasing depth

• Julia by example is all you need to go, if you have other programming language experience.
• Bogumił Kamiński, The Julia Express
• Boyd and Vandenberghe’s Julia Companion to their Introduction to Applied Linear Algebra is a solid introduction to both linear algebra and Julia, focussing especially on least-squares problems.
• Yoni Nazarathy and Hayden Klok, Statistics with Julia: Fundamentals for Data Science, Machine Learning and Artificial Intelligence (preprint) (Nazarathy and Klok 2021) is a good introduction to statistics, with a focus on the Julia language.
• Introducing Julia has the unfortunate leaden committee prose style of most wikibooks, but for sure will get you educated.
• Official documentation is fine but pedagogically arse-backwards, as official docs tend to be.

Here’s something that wasn’t obvious to me: What are Symbols?

And here is a neat heuristic:

A Mental Model for Julia: Talking to a Scientist

• When you’re talking, everything looks general. However, you really mean very specific details determined by context.
• You can quickly dig deep into a subject, assuming many rules, theories, and terminology.
• Nothing is hidden: if you ever want to hear about every little detail, you can ask.
• They will get mad (and throw errors at you) if you begin to be loose with the specific details.

—Chris Rackauckas, Intro to Julia.

2.2 Staying current

Julia is a fast-moving target. One way to catch the hype in the confusingly rapid evolution of the package ecosystem is to check out the package hotness in Julia observer.

3.1 Keyword arguments

Keyword arguments exist but do not participate in method dispatch. Keyword arguments are second-class citizens and might make things slow or stupid if you need to specialize your code based on them. So… design your functions around that. This is usually OK with careful thought, but small lapses lead to many irritating helper functions to handle default arguments. There is much idiomatic style to learn for this.

3.2 Traits and dispatch

Dispatching is not always obvious.

I tend to forget an important keyword: Value Types, which are what allows one to choose a method based on the value, rather than type of a thing. Their usage was not obvious (to me) from the manual but explained beautifully by Tim Holy. There are dangers.

Chris Rackaukas explains Holy Traits which are a Julia idiomatic duck typing method, explained in greater depth by Mauro3 as part of his discontinued Trails library. See also Lyndon White.

🏗

4.1 Strings: care and feeding

There are many formatting libraries, because everyone seems to dislike the built-in option, which eschews functions such as sensible user-defined formatting of floats.

Many alternatives seem to be based on Formatting.jl which apes Python string interpolation and this is IMO a reasonable baseline.

There is a friendly-ish fork, Format.jl which has a slightly different philosophy and provides an alternative string syntax, StringLiterals .

Mustache.jl also gained traction, being a generic templating syntax; it is easy to roll your own formatting from this.

4.2 Rich display

Julia has an elaborate display system for types, as illustrated by Simon Dernisch and Henry Shurkus.

tl;dr To display an object, invoke

display(instance)

Say you defined MyType. To ensure MyType displays sanely, define

show(io, instance::MyType)

e.g.

function show(io::IO, inst::MyType)
    print(io, "MyType(length=$(inst))")
end

Latexify (manual) marks up certain Julia objects nicely for markdown or TeX display.

latexify("x/y") |> print
$\frac{x}{y}$

PrettyTables aims to output ASCII tables, and happens to support LaTeX, HTML and various Markdown flavours.

TexTables.jl is a specialised table renderer for scientific table output with easy interface. It seems a little less active/popular.

More specialised, RegressionTables does statistical tables with baked-in analysis and a side-order of formatting. That feels too tightly coupled to me. Its launch announcement is a tour of the statistical ecosystem.

Matti Pastell’s useful reproducible document rendering system, Weave.jl, supports basic table displaying for Latex/HTML, although they recommend handballing it to Latexify.

Note that actually automatically generating table output is still more tedious than you’d like; for example, we should be using scientific notation. This generally requires writing custom formatters. Leandro Martinez walks us through that, or one can use ft_latex_sn the built-in PrettyTables helper.

10.1 Intermediate representation

I constantly search for this, so how ’bout I link it? The manual pages I need are Reflection and Metaprogramming. The latter has the parsed and interpolated representation documentation as used in macros. For inspecting my code to see what the language made of it I use @code_lowered, @code_warntype, @code_llvm depending on how much I wish to trade comprehensibility for precision.

10.2 What is this module?

Took me a while to work out that the current module is called @__MODULE__.

So if I want to look up a function by symbol, for example,

function makewindow(name::Symbol, args...; kwargs...)
    winfunc = getfield(@__MODULE__, name)
    makewindow(winfunc, args...; kwargs...)
end

11.1 Implementing standard interfaces for custom types

The type system is logical, although it’s not obvious if you are used to classical OOP. (Not a criticism.)

You want to implement a standard interface on your type so you can, e.g. iterate over it, which commonly looks like this:

for element in iterable
    # body
end

or equivalently

iter_result = iterate(iterable)
while iter_result !== nothing
    (element, state) = iter_result
    # body
    iter_result = iterate(iterable, state)
end

Here is an example of that: A range iterator which yields every nth element up to some number of elements could look like

julia> struct EveryNth
           n::Int
           start::Int
           length::Int
       end
julia> function Base.iterate(iter::EveryNth, state=(iter.start, 0))
           element, count = state

           if count >= iter.length
               return nothing
           end

           return (element, (element + iter.n, count + 1))
       end
julia> Base.length(iter::EveryNth) = iter.length
julia> Base.eltype(iter::EveryNth) = Int

(If you are lucky you might be able to inherit from AbstractArray.)

It’s weird for me that this requires injecting your methods into another namespace; in this case, Base. That might feel gross, and it does lead to surprising behaviour that this is how things are done, and some mind-bending namespace resolution rules for methods. Importing one package can magically change the behaviour of another. This monkey patch style (called, in Julia argot, “type piracy”) is everywhere in Julia, and is clearly marked when you write a package, but not when you use the package. Anyway it works fine and I can’t imagine how to handle the multiple dispatch thing better, so deal with it.

11.2 Array slicing may copy

You are using a chunk of an existing array and don’t want to copy? Consider using views for slices, they say, which means not using slice notation but rather the view function, or the @views macro. Both these are ugly in different ways so I cross my fingers and hope the compiler can optimise away some of this nonsense.

11.3 Custom containers are scruffy

If you need container types, the idiomatic way to do this is using parametric types and parametric methods and so-called orthogonal design.

The rule is: let the compiler work out the argument types in function definitions, but you should choose the types in variable definitions (i.e. when you are calling said functions)

(Thanks to Chris Rackauckas for clarifying this point for me.)

11.4 Containers of containers need parameterisation

It’s hard to work out what went wrong when you hear Type definition: expected UnionAll, got TypeVar.