One thing that did bother me:

> Since the Julia-creators also wanted it to be easy to learn, Julia fully supports dynamical typing. But in contrast to Python, you can introduce static types if you like — in the way they are present in C or Fortran, for example.

That's misleading. As Julia co-creator Stefan Karpinski puts it in this great Stack Overflow answer [1],

> This is not the way Julia works – code with type annotations is still dynamic and has the same semantics as code without type annotations.

> ...

> For the most part in Julia, type inference is just an optimization – your code will work the same way with or without it – but with successful type inference, it will run a lot faster.

[1]: https://stackoverflow.com/questions/28078089/is-julia-dynami...

In seriousness I have been enjoying it a lot over Python, but I'd kill for static typing.

It's highly expressive (comprehensions, functional-style all-statements-are-expressions, anonymous named tuples, and heaps more) and these features seem to be usable without sacrificing performance, in a way that I've not yet seen in any other language.

> Julia can be used for everything from simple machine learning applications to enormous supercomputer simulations. To some extent, Python can do this, too — but Python somehow grew into the job.

headscratch

In fact every argument the article makes other than _speed_ is in favor of Python.

> But in contrast to Python, you can introduce static types if you like — in the way they are present in C or Fortran, for example.

You can do that in python too via mypy.

One argument they make is that Julia is better because it has a smaller community which opens up old topics for new dicussions which is a really interesting thought but seems like grasping for straws here.

I'm not saying Julia is worse than Python but the article could have been 60% shorter and without all of the language-war click baits.

I’ve only used it to fit some linear models so far, and it’s obviously performant.

Eventually, I want to get around to writing an API with it, likely via https://genieframework.com/

For instance, Julia has a performant generational GC compared to Python's simple (but slow) refcount GC. This has the effect of not freeing up intermediate tensors immediately while doing backprop, thus leading to the premature exhaustion of GPU memory while training a deep neural net in Julia. This above issue was flagged with Flux.jl sometime back, and while I'm sure this has been fixed, it's also an illustration of how such low-level implementation details come back to bite.

Pytorch/Chainer etc. in contrast use a memory pool to manage GPU resources (the equivalent of malloc is quite slow), so that Python's 'slow' GC is actually a boon for deep learning workloads.

What happened was that my Julia programming environment just stopped working all by itself, with no apparent updates happening. That did not give me a warm feeling of reliability. This was about 2 years ago.

So how production-ready is Julia now?