A Summary of “Julia: A Fast

Dynamic Language for Technical

†
Computing” by Bezanson et al.

April 26, 2018

† B e z a n s o n , J . , K a r p i n s k i , S . , S h a h , V. B . , a n d E d e l m a n , A . ( 2 0 1 2 ) .
J u l i a : A Fa s t D y n a m i c L a n g u a g e F o r Te c h n i c a l C o m p u t i n g .
h t t p : / / a r x i v. o r g / a b s / 1 2 0 9 . 5 1 4 5

1
Background
Dynamic languages have become popular for computing
◦ Reasons/Pros
◦ Highly productive
◦ Convenient for development
◦ Typically shorter programs with increased readability
◦ Drawbacks/Cons
◦ Typically poorer performance than gold standards (C and Fortran)
◦ Often requires ”vectorized” code which can generate large temporary
objects that are not otherwise necessary
◦ Must use two-tiered approach for performance  learn two languages
◦ “Programming in two languages is more complex than using either
language by itself” †
◦ Creates a social barrier for most users
◦ Adds significant overhead and makes optimization difficult

2
More Background
Alternative to two-tier programming is to enhance the performance of
an existing dynamic language
◦ Significant progress for increasing performance
◦ Efforts exist for Python, LISP, etc.
◦ Has the advantage that existing code written in these languages can benefit
◦ Unfortunately, these projects have not actually eliminated the two-tier
approach
◦ “Design decisions made under the assumption that a language would be
implemented as an interpreter tend to sabotage the ability to generate
efficient code.” †

3
Result for Scientific Computing
The end result has largely been that engineering/scientific computing
has had to choose between performance and convenience.
Programs performing large numbers of calculations must resort to
Fortran or C for sake of efficiency.
Engineers writing smaller programs must sacrifice performance for
easier development.

Here at ERDC:
We spend thousands of dollars on software like MATLAB, MathCad,
etc. when much more efficient languages like C and Fortran are FREE!!!

4
Meet Julia
Julia is designed from the ground up to take advantage of modern
techniques for executing dynamic languages efficiently.
As a result, Julia has the performance of a statically compiled language
while providing interactive dynamic behavior and productivity like
Python, LISP or Ruby.
The key ingredients of performance are:
◦ Rich type information, provided naturally by multiple dispatch;
◦ Aggressive code specialization against run-time types;
◦ Just-In-Time (JIT) compilation using the LLVM compiler framework

5
Meet Julia
◦ Programming
◦ Using Julia with Atom+Juno

6
Julia vs.
Fortran

7
Free, Open Source,
and Library-Friendly
◦ Licensed under the MIT license
◦ Various Julia libraries include their own licenses such as GPL, LGPL,
and BSD so the environment is under the GPL
◦ Julia can be built as a shared library, so users can combine Julia with
their own C/Fortran code or proprietary third-party libraries
◦ Simple to call external functions in C and Fortran shared libraries
◦ No wrapper required – no need to recompile existing code
◦ Easy to test external library functions directly from Julia’s
interactive prompt so you get immediate feedback

8
Still not convinced?

Julia

9
Questions?

10