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 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
Shift + Enter Evaluate current section and jump to next.

Basic 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("./");
Pkg.instantiate();

String Interpolation

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

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 an iterable to an array with collect
myArr = collect(1:3)

// 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

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

Object Oriented Programming

Julia is a Multiple Dispatch language.
You can use a struct in place of classes and define functions which have your struct as a parameter in place of methods.
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.