Yesterday I gave a short lightning talk at the Inria Devmeetup about Julia. My intention was to show a few of the design aspects of this rather recent programming language and motivated from my experiences in my current PostDoc project at the MATHERIALS team hint at interesting ongoing developments. For this I chose to show some (hopefully) representative code examples in a Jupyter notebook, interactively running the Julia code using an IJulia kernel.

For demonstrating Julia's **multiple dispatch** paradigm,
I hinted how functionality (like the `mysquare`

function in my example) can be easily implemented in a way
such that code can be combined with multiple different
computational backends.
Such backends include distributed array storage for large
chunks of data or arrays of static size,
where the size information may be used at compile-time
to speed up the byte code for small problems.
GPU backends are possible as well, but I did not go into this
in my presentation.
With respect to speed I show **some timings** from a heat equation
example (courtesy Antoine Levitt)
comparing a `Julia`

, a `python`

and a `C`

implementation.
Last but not least I hinted at the **interoperability**
with python packages and Fortran code
and showed a plotting example,
where I used Zygote
to automatically compute and show the gradient
of a function using **adjoint-mode automatic differentiation**.

The notebook I used for the presentation is both attached below and can be found on github as well. For a rendered version of the notebook you can open it in nbviewer.

Link |
---|

Julia: A numerical programming language (Notebook lightning talk) |

View notebook in nbviewer |