Why I’m Not a Fan of the Julia Programming Language

The Julia programming language is a relatively new (still in development) general purpose language intended mostly for use with numerical and scientific programming. I tried out Julia v1.0 about two years ago and wasn’t impressed — at that time Julia clearly wasn’t ready for prime time. One weekend I took a fairly close look at the current v1.6 to see if my opinion would change. It didn’t.

When compared to the Python language, Julia has one big advantage for me — it has numerical capabilities built in, as opposed to Python’s crazy requirement to import the NumPy library. But based on every other attribute, Julia doesn’t come close to Python for the work I do.

Speed – The julialang.org Web site states “Julia was designed from the beginning for high performance”. Fast is good but in my work with machine learning, Python programs are either fast enough (under 20 minutes to execute) or not feasible (many hours or days to execute). Julia’s speed advantage only impacts a tiny fraction of the programs I write. If I need fast, I’ll use the C/C++ language.

Bugs – Julia is just not stable enough for my work. It took Python many years to reach the nearly bug-free state it’s at now. Julia likely won’t become essentially bug free for several years. I cannot afford to work with a language that might have a hidden bug.

Packages and Libraries – Even though Julia has a lot of support from its community, because Julia is new, it doesn’t have the packages and libraries that Python has. You have to work hard to find an area where Python doesn’t have a production quality package available. Julia has nothing close to the Keras or PyTorch libraries for deep neural networks, the most important area of ML for me.

# Julia example
# calculates x for 0 = a*x^2+b*x+c
function quadratic(a::Float64, b::Float64, c::Float64)
  # unlike other languages 2a is equivalent to 2*a
  # a^2 is used instead of a**2 or pow(a,2)
  sqr_term = sqrt(b^2-4a*c)
  r1 = quadratic(a, sqr_term, b)
  r2 = quadratic(a, -sqr_term, b)
  # multiple values can be returned from a function using tuples
  # if the return keyword is omitted, the last term is returned
  r1, r2
end

quad1, quad2 = quadratic(2.0, -2.0, -12.0)
println("result 1: ", quad1)
# result 1: 3.0
println("result 2: ", quad2)
# result 2: -2.0

Collaboration – Even though Julia has a vigorous community, compared to Python, the size of that community is tiny. This means that when I’m implementing a system at work with a view towards that system being used in production code or by other teams, there’s about zero chance that any potential collaborators will want to use Julia. A related effect is that every time I use Python, I increase my skillset that has value in terms of jobs and career; using Julia at this time will not help much because the language just isn’t used much compared to Python.

Culture Nastiness – I don’t like the attitude of the guys who created Julia. I believe they originally had good intentions, but when the creators formed a company “Julia Computing Inc.” in 2015, it became all about monetizing the language. A Julia contributor mildly made some constructive criticism about certain technical aspects of Julia in his blog post and was attacked by the Julia leadership. See https://danluu.com/julialang/.

Additionally, the Julia leadership makes all kinds of claims that are not true and are designed to foster increased revenue or investment in some way. In a Forbes Magazine article, one of the Julia founders said, “Amazon, Apple, Disney, Facebook, Ford, Google, Grindr, IBM, Microsoft, NASA, Oracle and Uber are other Julia users, partners and organizations hiring Julia programmers,” says Shah. This is not true. I work for one of those companies and we do not use Julia and our jobs site has zero references to the term “julia”. Maybe some people use Julia for experimentation, but no product or service group uses Julia for serious code.

And, “Julia empowers data scientists, physicists, quantitative finance traders and robot designers to solve problems without having to become computer programmers or hire computer programmers to translate their functions into computer code,” claims Karpinski. What?

So, the bottom line is that Julia isn’t ready for the type of work I do. And even if it was, I would avoid Julia because of the sketchy self-serving statements made by the people at Julia Computing Inc.



A Julia set fractal with six different colorings. Julia set fractals start with a complex number z = x + yi where i = sqrt(-1) and x and y are pixel coordinates. Then z is repeatedly updated using z = z^2 + c where c is another complex number that gives a specific Julia set. After many iterations, if the magnitude of z is less than 2 the associated pixel is in the Julia set and it’s colored depending on its magnitude.

This entry was posted in Machine Learning. Bookmark the permalink.

Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s