Recently I have been playing around with the Julia programming language as a way to run some cheap simulations for some geometric analysis stuff that I am working on. So far the experience has been awesome.

A few random things …

Juno

Julia has a decent IDE in JunoLab, which is built on top of Atom. In terms of functionality it captures most of the sort of things I used to use with Spyder for python, so is very convenient.

Jupyter

Julia interfaces with Jupyter notebooks through the IJulia kernel. I am a fan of Jupyter (I will be using it with the MATLAB kernel for a class I am teaching this fall).

Plots.jl

For plotting, right now one of the most convenience ways is through Plots.jl, which is a plotting front-end the bridges between your code and various different backends that can be almost swapped in and out on the fly. The actual plotting is powered by things like matplotlib or plotlyJS, but for the most part you can ignore the backend. This drastically simplifies the production of visualizations. (At least compared to what I remembered for my previous simulations in python.)

Automatic Differentiation

I just learned very recently about automatic differentiation. At a cost in running time for my scripts, it can very much simplify the coding of the scripts. For example, we can have a black-box root finder using Newton iteration that does not require pre-computing the Jacobian by hand:

```module NewtonIteration
using ForwardDiff

export RootFind

function RootFind(f, init_guess::Vector, accuracy::Float64, cache::ForwardDiffCache; method="Newton", max_iters=100, chunk_size=0)
### Takes input function f(x::Vector) → y::Vector of the same dimension and an initial guess init_guess. Apply Newton iteration to find solution of f(x) = 0. Stop when accuracy is better than prescribed, or when max_iters is reached, at which point a warning is raised.
### Setting chunk_size=0 deactivates chunking. But for large dimensional functions, chunk_size=5 or 10 improves performance drastically. Note that chunk_size must evenly divide the dimension of the input vector.
### Available methods are Newton or Chord

# First check if we are already within the accuracy bounds
error_term = f(init_guess)
if norm(error_term) < accuracy
info("Initial guess accurate.")
return init_guess
end

# Different solution methods
i = 1
current_guess = init_guess
if method=="Chord"
df = jacobian(f,current_guess,chunk_size=chunk_size)
while norm(error_term) >= accuracy && i <= max_iters
current_guess -= df \ error_term
error_term = f(current_guess)
i += 1
end
elseif method=="Newton"
jake = jacobian(f, ForwardDiff.AllResults, chunk_size=chunk_size, cache=cache)
df, lower_order = jake(init_guess)
while norm(value(lower_order)) >= accuracy && i <= max_iters
current_guess -= df \ value(lower_order)
df, lower_order = jake(current_guess)
i += 1
end
error_term = value(lower_order)
else
warn("Unknown method: ", method, ", returning initial guess.")
return init_guess
end

# Check if converged
if norm(error_term) >= accuracy
warn("Did not converge, check initial guess or try increasing max_iters (currently: ", max_iters, ").")
end
info("Used ", i, " iterations; remaining error=", norm(error_term))
return current_guess
end

end

```

This can then be wrapped in finite difference code for solving nonlinear PDEs!