Julia is an open-source, multi-platform, high-level, high-performance programming language for technical computing.

Julia has an LLVM Low-Level Virtual Machine (LLVM) is a compiler infrastructure to build intermediate and/or binary machine code. -based JIT Just-In-Time compilation occurs at run-time rather than prior to execution, which means it offers both the speed of compiled code and the flexibility of interpretation. The compiler parses the code and infers types, after which the LLVM code is generated, which in turn is compiled into native code. compiler that allows it to match the performance of languages such as C and FORTRAN without the hassle of low-level code. Because the code is compiled on the fly you can run (bits of) code in a shell or REPL Read-Eval-Print-Loop , which is part of the recommended workflow .

Julia is dynamically typed, provides multiple dispatch Because function argument types are determined at run-time, the compiler can choose the implementation that is optimized for the provided arguments and the processor architecture. , and is designed for parallelism and distributed computation.

Julia has a built-in package manager.

Julia has many built-in mathematical functions, including special functions (e.g. Gamma), and supports complex numbers right out of the box.

Julia allows you to generate code automagically thanks to Lisp-inspired macros.

Julia was created in 2012.

A variable, in Julia, is a name associated (or bound) to a value. Notice that for most complex types, it will not copy the underlying data! For example

x = [1,2,3]
y = x 
y[1] = 10
x[1] == 10  # this is true, since x and y are associated to the same array

To help Julia load faster, many core functionalities exist in standard libraries that come bundled with Julia. To make their functions available, use using PackageName. Here are some Standard Libraries and popular functions.

Packages must be registered before they are visible to the package manager. In Julia, there are two ways to work with the package manager: either with using Pkg and using Pkg functions, or by typing ] in the REPL to enter the special interactive package management mode. (To return to regular REPL, just hit BACKSPACE on an empty line in package management mode).

In Interactive Package Mode

Using Pkg in Julia session

Beware of multi-byte Unicode encodings in UTF-8:
10 == lastindex("Ångström") != length("Ångström") == 8

Strings are immutable.

Julia does not automatically check for numerical overflow. Use package SaferIntegers for ints with overflow checking.

Many random number functions require using Random.

For most linear algebra tools, use using LinearAlgebra.

Julia has built-in support for matrix decompositions.

Julia tries to infer whether matrices are of a special type (symmetric, hermitian, etc.), but sometimes fails. To aid Julia in dispatching the optimal algorithms, special matrices can be declared to have a structure with functions like Symmetric , Hermitian , UpperTriangular, LowerTriangular, Diagonal , and more.

All arguments to functions are passed by reference.

Convention: Functions with ! at the end of the name change at least one argument, typically the first, e.g. sort!(arr).

There are three kinds of arguments:

• Required arguments are separated with a comma and use the positional notation.
• Optional arguments come after required arguments and have a default value, defined with =.
• Keyword arguments use the named notation and are listed in the function’s signature after the semicolon.

function func(req1, req2, opt1 = 1; key1="x", key2=0)
    # do stuff
end

The semicolon is not required in the call to a function that accepts keyword arguments.

The return statement is optional but highly recommended. (Without return, the function returns the value of the last line.)

Multiple variables can be returned as a tuple in a single return statement.

Functions can have explicit input and return types

# take any Number subtype and return it as a String
function stringifynumber(num::Number)::String
    return "$num"
end

Multiple dispatch: Functions can have multiple definitions for different input types. At each call, the most spezialized definition will be used, e.g.

intbyfloat(x,y) = NaN
intbyfloat(x::Int64,y::Float64) = x/y
intbyfloat(x::Float64,y::Int64) = y/x

intbyfloat(1,2.0) == 1/2.0  # calls second definition
intbyfloat(3.0,2) == 2/3.0  # calls third definition
isnan( intbyfloat(3.0, 3.0) ) # calls first definition

Functions can be vectorized by using the Dot Syntax

# here we broadcast the addition and the call of f(x)
A = rand(3, 4)
B = A .- randn(3,4)  # broadcast '-'

f(x) = 2x-1
C = f.(B)            # broadcast 'f'

Alternative ways to define functions are one line functions and anonymous functions.

One line functions use = instead of return

f(x,y=1;z=2) = x+y*z

Anonymous functions do not have a function name and use -> instead of return

(x,y=1;z=2) -> x+y*z 

They can be used for example in collection functions or list comprehension, e.g.

sort([1,2,3], by = (x) -> 1/sin(x)) 
map((x,y) -> x/y^2, 1:10, 2:11)

Anonymous functions can best be used in collection functions or list comprehensions: x -> x^2.

Functions can accept a variable number of arguments:

function func(a...)
    println(a)
end

func(1, 2, [3:5]) # tuple: (1, 2, UnitRange{Int64}[3:5])

Functions can be nested:

function outerfunction()
    # do some outer stuff
    function innerfunction()
        # do inner stuff
        # can access prior outer definitions
    end
    # do more outer stuff
end

Parametric functions

Julia generates specialized versions Multiple dispatch a type of polymorphism that dynamically determines which version of a function to call. In this context, dynamic means that it is resolved at run-time, whereas method overloading is resolved at compile time. Julia manages multiple dispatch completely in the background. Of course, you can provide custom function overloadings with type annotations. of functions based on data types. When a function is called with the same argument types again, Julia can look up the native machine code and skip the compilation process.

The existence of potential ambiguities is acceptable, but actually calling an ambiguous method is an immediate error.

Stack overflow is possible when recursive functions nest many levels deep. ```

Tuples are like inmutable arrays with static types.

NamedTuples are like Tuples but the elements have (static) names and allow access as data as fields.

Dictionaries are mutable; when symbols are used as keys, the keys are immutable.

Checking whether an element is contained in a set is done in O(1).

Julia has no classes and thus no class-specific methods.

Types are like classes without methods.

Abstract types can be subtyped but not instantiated.

Concrete types cannot be subtyped.

By default, struct s are immutable.

Immutable types enhance performance and are thread safe, as they can be shared among threads without the need for synchronization.

Objects that may be one of a set of types are called Union types.

When a type is defined with an inner constructor, the default outer constructors are not available and have to be defined manually if need be. An inner constructor is best used to check whether the parameters conform to certain (invariance) conditions. Obviously, these invariants can be violated by accessing and modifying the fields directly, unless the type is defined as immutable. The new keyword may be used to create an object of the same type.

Type parameters are invariant, which means that Point{Float64} <: Point{Real} is false, even though Float64 <: Real. Tuple types, on the other hand, are covariant: Tuple{Float64} <: Tuple{Real}.

The type-inferred form of Julia’s internal representation can be found with code_typed(). This is useful to identify where Any rather than type-specific native code is generated.

Modules are separate global variable workspaces that group together similar functionality.

With using Foo you need to say function Foo.bar(... to extend module Foo’s function bar with a new method, but with import Foo.bar, you only need to say function bar(... and it automatically extends module Foo’s function bar .

Julia is homoiconic: programs are represented as data structures of the language itself. In fact, everything is an expression Expr.

Symbols are interned strings Only one copy of each distinct (immutable) string value is stored. prefixed with a colon. Symbols are more efficient and they are typically used as identifiers, keys (in dictionaries), or columns in data frames. Symbols cannot be concatenated.

Quoting :( ... ) or quote ... end creates an expression, just like Meta.parse(str) This form is probably most familiar to people with knowledge of dynamic SQL. The Meta.parse function is similar to Oracle”s and PostgreSQL”s EXECUTE IMMEDIATE statement or SQL Server’s sp_executesql() procedure. , and Expr(:call, ...).

x = 1
line = "1 + $x"         # some code
expr = Meta.parse(line) # make an Expr object
typeof(expr) == Expr    # true
dump(expr)              # generate abstract syntax tree
eval(expr) == 2         # evaluate Expr object: true

Macros allow generated code (i.e. expressions) to be included in a program.

Rules for creating hygienic macros:

• Declare variables inside macro with local .
• Do not call eval inside macro.
• Escape interpolated expressions to avoid expansion: $(esc(expr))

Multithreading is provided by the Threads standard package.

Parallel computing tools are available in the Distributed standard library.

Workers are also known as concurrent/parallel processes.

Modules with parallel processing capabilities are best split into a functions file that contains all the functions and variables needed by all workers, and a driver file that handles the processing of data. The driver file obviously has to import the functions file.

For dplyr-like tools, see DataFramesMeta.jl.

Many core packages are managed by communities with names of the form Julia[Topic].

The main convention in Julia is to avoid underscores unless they are required for legibility.

Variable names are in lower (or snake) case: somevariable.

Constants are in upper case: SOMECONSTANT.

Functions are in lower (or snake) case: somefunction.

Macros are in lower (or snake) case: @somemacro.

Type names are in initial-capital camel case: SomeType.

Julia files have the jl extension.

For more information on Julia code style visit the manual: style guide .

See Julia Manual - Performance tips.

• Performance critical code should be inside a function.
• Avoid global variables.
• Measure performance with @time or @btime and pay attention to memory allocation.
• Use Profiling or other analysis tools. (e.g. Juno.@profiler and @code_warntype)
• Avoid containers with abstract type parameters
• Type declarations are only needed when the compiler cannot predict the type.
• Use immutable types where possible.
• Avoid Any in collections.
• Avoid abstract types in collections.
• Write type-stable functions.
• Separate kernel functions (aka, function barriers)
• Use sizehint! for large arrays.
• Access arrays along columns, because multi-dimensional arrays are stored in column-major order.
• Pre-allocate outputs.
• Use @. to fuse vectorized operations.
• Consider using @view for slices.
• Avoid the splat (...) operator for keyword arguments.
• Use mutating APIs (i.e. functions with ! to avoid copying data structures.
• Avoid try-catch in (computation-intensive) loops.
• Avoid string interpolation in I/O.
• Vectorizing does often not improve speed (unlike R, MATLAB or Python).
• Avoid eval at run-time.

• Juno (editor)
• Jupyter (online IJulia notebook)
• Emacs Julia mode (editor)
• Pluto.jl (online IJulia notebook)
• vim Julia mode (editor)
• VS Code extension (editor)

• Official documentation .
• Learning Julia page.
• Community standards .
• Julia Discourse forum
• Julia: A fresh approach to numerical computing (pdf)
• Julia: A Fast Dynamic Language for Technical Computing (pdf)

• Julia YouTube Channel
• Julia for Programmers
• The Unreasonable Effectiveness of Multiple Dispatch
• Make your Julia Code Faster and Compatible with non-Julia Code