Takeaways from the Julia workshop

[gnawin]

Hi all,

Recently I attended a Julia training workshop.

Below are my main takeaways, and if you are further interested, the full material can be found here.

Maybe we find some inspirations to improve Tulipa.

Basics

• Julia obtains its performance from being a just-in-time (JIT) compiler, This means it compiles when you run the code. The first time it takes time and the following time it will be fast because the compilation is complete.
• Macros (metaprogramming) transform code at compile-time. This is more performant but also do not abuse it because it makes the code less readable. To see what a macro is doing, use @macroexpand, e.g., @macroexpand @assert false "Oh, noes!"
• Put everything in a function! Functions are compiled when called for the first time, but global variables are not.
• In Julia, everything is an expression, meaning that it returns a value. Think of an if-else statement or a function definition. They always return values so you can assign them to a variable. This is also why adding return in functions is only optional.
• Julia is lexically scoped. This means that variables do not outlive the block that they’re defined in.
• There are abstract types. However, abstract type itself cannot be initiated.
• There are constructors for structs, allowing for flexible ways of using structs.

Performance

• Type stability is important. But it does not mean that you have to explicitly tell the type, you can also use a parametric type (often T) to be generic and type stable.
• eachindex and relatives (think of keys, values, pairs, enumerate, zip) are good ways to iterate collections.
• Growing arrays dynamically induces (memory) allocations. If possible, allocate beforehand, by e.g., result = Vector{Float64}(undef, n).
• We can discover type instability using @profview, and analyze further using @code_warntype. Using profview, the red areas in the flame graph show type unstable code (marked with run-time dispatch).
• Don’t use global mutable variables. This can lead to type instability.
• Value types are a useful and efficient abstraction. If N is a small number, use Val(N) instead of just N.
• Use StaticArrays instead of the build-in Array.
• Consider parallel computation, e.g., multi-threading (maybe good for IO tasks in Tulipa) or GPU programming.
• A good summary on type stability can be found in the following blog post: - Writing type-stable Julia code

Misc

• Use Makie and stay away from Plots.
• @kwdef allows to give initial values for structs. So instead of using functions to initialize, this is more concise.
• Check out Unitful.jl.

[datejada]

Thanks! It is an excellent summary 😄

For the Units, we have this issue #257, so we should also double-check UnitJuMP.jl which is built on top of Unitful.jl and is specific to check units in JuMP.