One Does Not Simply Walk Into Mordor: Julia, the last language?

Just wanted to let you all know that one does not simply give up Julia.

I attempted to do this without being able to evaluate in advance how hooked my brain became on multiple dispatch. With some effort, I can compensate for metaprogramming by using other languages - but multiple dispatch is a f-king virus.

Julia seems to be my last language (the way @mbauman expressed it here).

P. S. The reasons why I attempted to give up the language were philosophical and related to the ex-cathedra way of communication of some elite users (and also associated with academicism - the nasty flavor). I don’t care about it anymore - that can no longer interfere with my Julia way. I know that now.

P. P. S. I don’t want to talk about the above P. S.


I recently had to jump to C++ for a project where hardware compatibility required it. And just like you, I found multiple dispatch had infected my brain. My C++ is now highly templated and I make extensive use of function overloading in a way I doubt I would have before using Julia.

Which is weird, because when I present on Julia and try to extol the virtues of multiple dispatch I often find I can’t make a convincing case.

For that matter, I also refused to give up my use lambdas, higher order functions and more generally functional idioms when jumping to C++. These are obviously not unique to Julia but I haven’t used them to the extent I currently am in any other language, with the exception of Haskell.


Another thing – the fluidity of Documenter.jl is highly underrated IMO. I am trying to write some docs for a Python project at work, and it is so painful.


I also am beginning to really like multiple dispatch, but I am not yet fluent with it. Even so, with shockingly little time spent, I have re-written a lot of our tools in Julia, and they run like greased lightning. The vocal Fortran people have stopped talking about how fast Fortran is, because they are so far behind in development … :).

I started out in Fortran, moved through various C flavors, then on a whim tried reading The Little Schemer and SICP … previously I had dismissed “functional” programming as too academic, but I found it to be very expressive and fun, but it took me a while to get comfortable with it. It forever changed how I wrote code - even in other languages. I’m sure that with time, multiple dispatch will have a similar effect.


Most software was written without multiple dispatch, so it’s not reasonable to convince people that they really need it. Despite having said that, I do really appreciate how multiple dispatch makes composition easier (only fair because a tradeoff of no concrete supertypes is no inheritance of fields). It’s easy to dispatch Julia methods on multiple components instead of a single composite, so it’s also easier to keep larger composites as flat as possible by containing the components instead of other composites. Meanwhile in primarily single-dispatch languages it’s easier for composites to get very nested with multiple stages of forwarding, and if it is at all possible to work around you’d have to know your way around method overloading, templates, virtual overriding, static vs runtime dispatch, yada yada yada.