Julia

Julia is a numerical computation and general purpose high-level programming language. It's standout feature is its performance which allows libraries to be written in Julia directly. In contrast, many libraries in R and Python are written in C (programming language) or C++ for performance purposes and accessed using Rcpp or Cython. If necessary, you can still interface with other languages. See Introducing Julia for a comprehensive guide on how to program in Julia.

Installation

Juno

Juno is an IDE for Julia. It consists of a set of packages added to Atom. Most items can be accessed from the Atom control palette Ctrl + Shift + P
Shortcuts:

• Ctrl + Enter Evaluate current selection/section.
• Shift + Enter Evaluate current selection/section and jump to next.

Usage

Package Management

Guide

Initializing a new project

cd project_folder
julia
] activate ./
# Add your packages

Loading an existing project

cd project_folder
julia
using Pkg;
Pkg.activate(@__DIR__);
Pkg.instantiate();

Updating an existing project

If the dependencies in Project.toml have been updated, you will need to run Pkg.resolve() to install new packages and update your local Manifest.toml

using Pkg;
Pkg.activate(@__DIR__);
Pkg.resolve();

To update the your dependencies, run Pkg.update()

using Pkg;
Pkg.activate(@__DIR__);
Pkg.update();

Other Pkg Commands

You can see all the commands by typing ? in the package manager.

• add [packagename] Add a package
• update [packagename] Update a specific package or all packages
• remove [packagename] Remove a package
• status Show the current Pkg directory and installed packages

Basics

Functions

You can chain functions using the pipe operator |>. This is similar to %>% in R or |> in F#

a = [1,2,3];
// Equivalent to sum(a)
b = a |> sum

Strings

String Interpolation

"Variable x is $x, y is $y, and x+y is $(x+y)"

String Concatenation

Julia uses * to concatenate strings. You will get an error if you use +.

"a"*"b"

Arrays

[Full details]

// Make an 1d array of Float64.
// Equivalent to [0.0, 0.0, 0.0]
myArr = zeros(4);

// Make a 1d array of Float64 left to uninitialized values
myArr = Array{Float64,1}(undef, 3)

// Convert a collection to an array with collect
myArr = collect(1:0.5:3)
// myArr == [1.0,1.5,2.0,2.5,3.0]

// Reference copy
a = [1, 2, 3];
b = [4, 5, 6];
b = a

// Shallow copy
a = [1, 2, 3];
b = [4, 5, 6];
// elementwise equals operator
b .= a
// or b[:] = a
// or b = copy(a) (this will discard the original b)

// Basic functionality
// Call functions elementwise by adding . after the function name
a = [1, 5, 99];
a = clamp.(a, 1, 11);
// a is now [1, 5, 11]
// Equivalent to clamp!(a, 1, 11)

// Julia also has map, foldl, foldr, reduce

Higher order functions

Julia supports high-order functions.

ts = ((a, b) -> (c, d) -> a + b + c + d)(1,2);

The call with arguments (1,2) returns a function.
Then ts is equivalent to

ts = (c, d) -> 1 + 2 + c + d;

You can also use the full function(a,b) syntax.

Animation Loop

You can use Timer(callback, delay, interval). This is similar to SetInterval in JavaScript.
End the loop with close(animate).

animate = Timer(function(t)
    println("Animating")
end, 0; interval=1/60)

Graphics

Main article: Graphics in Julia

You can use MeshCat.jl to create visualizations to view in a web browser.
These visualizations are powered by WebGL using three.js.
Note that MeshCat.jl only exposes a small subset of three.js's features so I would not recommend it for creating highly intricate or interactive experiences at the moment.
MeshCat.jl is built using WebIO.jl.

Machine Learning

Main article: Machine Learning in Julia

See Flux and Knet.jl

Object Oriented Programming

Julia is a Multiple Dispatch language.
You can use a struct in place of classes and define methods which use your struct as a parameter.
You can find all definitions of a function using the methods function. For example:

using Parameters
# @with_kw allows default values
# By default, structs are immutable. Add the mutable keyword.
@with_kw mutable struct Person
  name
  age
end

# Outer constructor
function Person(name::String, age::Int)
  # Do anything here
  # Return a new Person
  Person(name = name, age = age)
end

Useful functions:

# Returns the type
typeof("str")
# Check type
"str" isa String
# Get the super type
supertype(Int64)
# Check if a is a subtype of b with <:
# This is the same symbol for creating a subtype of an abstract type
# E.g. mutable struct myNum <: Number
Int64 <: Number

Useful Packages

MeshCat.jl

Link
A wrapper for graphics visualizations around three.js. This opens in a web browser but can be used for making helium apps. See Graphics in Julia for more details on how to use MeshCat.jl.

Flux

Link
Flux is the largest machine learning library for Julia. It includes convenience features including NN layers, activation functions, and an automatic differentiation system. See Machine Learning in Julia for more details on how to use Flux.

Latexify.jl

Link
Prints out a latex string for any Julia expression or value.
Very useful for printing out matrices to insert into Latex documents.