The Scientist's Dilemma
For decades, scientists and engineers were stuck in a frustrating loop known as the “two-language problem.” They would prototype their ideas in an easy-to-use but slow language like Python or MATLAB. Once the concept was proven, the real work began: rewriting
the entire program in a fast but complex language like C++ or Fortran to get the performance needed for production. This process was slow, expensive, and a major source of bugs. The creators of Julia, in their 2012 manifesto, declared themselves “greedy” for wanting to break this cycle. They wanted one language that could do both: be easy enough for initial exploration and fast enough for final execution.
A Path Less Traveled
To solve this, Julia’s creators didn't just build another fast language; they rethought a fundamental concept of how programming languages work. Most popular object-oriented languages, like Python or Java, use a paradigm called single dispatch. In simple terms, when you call a function like `animal.make_sound()`, the specific sound that’s made is determined by the type of the `animal` object. The object itself owns the function. Julia's creators—Jeff Bezanson, Stefan Karpinski, Viral Shah, and Alan Edelman—chose a different path. They built the entire language around a concept called multiple dispatch.
Enter Multiple Dispatch
Multiple dispatch flips the script. Instead of the function belonging to an object, the function is a more general concept, and the specific version that runs depends on the types of all of its arguments. Think of it like a chef choosing a recipe. A single-dispatch chef would look only at the protein (`chicken.cook()`) and decide what to do. A multiple-dispatch chef looks at all the ingredients (`cook(chicken, lemon, rosemary)`) and chooses a specific, highly optimized recipe for that exact combination. This may seem like a subtle, academic distinction, but its consequences are profound. It allows a function to have many different methods, each specialized for a different combination of inputs.
The Compounding Payoff
This decision is the secret sauce that solves the two-language problem. Because Julia knows the exact types of all variables going into a function at runtime, its just-in-time (JIT) compiler can generate incredibly efficient, specialized machine code that rivals C. Users can write high-level, readable code, and the multiple dispatch system ensures it will be compiled into the fastest possible version for the specific data being used. This also makes Julia incredibly “composable.” Packages written by different developers who have never met can seamlessly work together. A package for solving differential equations can work directly with a package for handling units of measurement, because the functions can adapt to the combination of types from both.
Why It's 'Forgotten'
If multiple dispatch is so great, why isn't it more common, and why is it a “forgotten” part of Julia's story? Because for many users, it just works quietly in the background. As co-creator Stefan Karpinski noted, many early users came for the speed but stayed for the features, chief among them multiple dispatch. However, this different approach does come with trade-offs. It can make the initial learning curve a little steeper for programmers accustomed to object-oriented languages. It also contributes to what’s known as the “time-to-first-plot” problem, where Julia can feel slow to start up as it compiles all the necessary function methods for the first time.
