Haskell and LISP are old, Julia isn’t

Julia fans are much like functional programming proponents. They can’t shut up how great it is, yet barely anybody uses it. Could it be that they’re missing a good part of the picture?

The problem with this analogy is that a lot of the functional languages have been around for a long time now. Functional programming has been successful in the sense that functional constructs have been incorporated and increasingly promoted in almost every modern programming language.

However you are probably thinking of the failure of Haskell and LISP to gain traction in the mainstream.

I think there are very good reasons for their failure to do so. The problem with trying to create an analogy to Julia, is that these functional languages have been around for many years without gaining traction. Julia in contrast is a fairly young language, but which is still growing rapidly.

You cannot release a new language and expect 100 million developers or something 3 months later. Libraries have to be added, quirks ironed out, experience of usage has to be shared.

We Julia fans talk a lot about Julia because it is awesome and actually solves a lot of real problems for people. Nothing wrong about being passionate about something you care about.

The problem arise when you are imperivious to criticism. Haskell e.g. is a beautiful piece of engineered software, and I can understand why proponents get exicted about it. However Haskell advocates are all too often papering over the fact that Haskell is not a beginner friendly language. It takes considerable time to master.

And when you finally master it, real world examples don’t really demonstrate a clear advantage of using Haskell. Many other language offer equal of better performance. Many other language offer better productivity. There is no clear proof that Haskell leads to fewer bugs.

Thus with functional fans insist Haskell is God’s own language, I can understand that may come across as annoying.

However we are not in that situation with Julia at all. Here are important differences:

1. Julia has in large part proven itself already. A lot of researchers are seeing big productivity and performance gains. Large high performance projects like Celeste and CliMA are using Julia.
2. Unlike many functional languages such as Haskell, OCaml, Scala etc Julia is quick to learn. You don’t need a PhD in type systems to grok it. It is beginner friendly.
3. You can reuse existing knowledge. If you try Haskell, LISP, Smalltalk and a number of other well designed beautiful languages a frequent problem is that they are a world onto themselves. Libraries, APIs and conventions are all new. With Julia you can reuse old knowledge. If you know Matlab, Python, R, C, LISP, Ruby or maybe even Go there is some opportunity to reuse old skills. E.g. I have pretty much copy pasted Matlab code into my Julia editor and made minor modifications to make it run. Good luck trying that in Haskell.
4. Like Python, Perl and Ruby before it, Julia is a great glue language. It can integrate well with C libraries, Unix shell and even Python and R. That is probably a key reason why Python gained such traction in the first place over cleaner or more elegant languages.

So bottom line is that Julia is a great package. It is not just a well designed language, but it also delivers productivity and performance while being pragmatic and easy to pick up.

If you spent some time with it, there is a high chance you would get why we are so hyped about Julia 😉.