# Does Julia Create a "1.5" Language Problem?

**URL:** <https://discourse.julialang.org/t/does-julia-create-a-1-5-language-problem/107984>\
**Category:** Teaching & Outreach\
**Tags:** question, discussion\
**Created:** [December 23, 2023, 6:44pm UTC](https://discourse.julialang.org/t/does-julia-create-a-1-5-language-problem/107984 "2023-12-23T18:44:23Z")\
**Posts on this page:** 1\
**Showing post:** 77

<div class="post-metadata">

**Author:** ![mkitti](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/mkitti/32/12459_2.png) [@mkitti](https://discourse.julialang.org/u/mkitti)\
**Post date:** [December 29, 2023, 3:58am UTC](https://discourse.julialang.org/t/does-julia-create-a-1-5-language-problem/107984/77 "2023-12-29T03:58:09Z")

</div>

The last talk at JuliaCon Eindhoven Local, Myrthe Schepper’s talk on “ASML’s Julia Journey”, references the earlier talk about the “1.5 language problem”.

[![](https://global.discourse-cdn.com/julialang/original/3X/f/0/f03d5abfaca3ba5643cfd4b4fe9f07e6a2363575.jpeg "Myrthe Scheepers - ASMLs Julia Journey") ](https://www.youtube.com/watch?v=Nf70byblWEU)

There she touched on two culture problem that had been articulated by @MatthijsCox in his Scientific Coder blog.

- [The Two Culture Problem](https://scientificcoder.com/my-target-audience#heading-the-two-culture-problem)
- [How to solve the two language problem?](https://scientificcoder.com/how-to-solve-the-two-language-problem)

Some of the issues Julia faces are a manifestation of [Conway’s Law](https://en.wikipedia.org/wiki/Conway%27s_law). In short, we are likely to end up with two dialects of Julia as we try to integrate both the interests of researchers and software engineers.

We previously discussed some of these items in two prior threads.

> [@Julia solves a two-language problem but the real problem is a 3-wants problem which Julia does not necessarily serve well atm](https://discourse.julialang.org/t/julia-solves-a-two-language-problem-but-the-real-problem-is-a-3-wants-problem-which-julia-does-not-necessarily-serve-well-atm/96295):
>
> Julia solves the two language - write the algo in a slow language and then reimplement it in fast language. However, that is not the biggeest two language. The real problem is this Modeler write code for their models Software engineers put code into production It’s a pain to productionise code not in the sense that you can’t run a R glm model or a Python Pytorch model in a production environment it’s that those productionised systems are brittle. It fails with if the wrong type of data is p…

> [@Roadmap for small binaries](https://discourse.julialang.org/t/roadmap-for-small-binaries/99266):
>
> Hi All, I saw this question first popped up at JuliaCon 2021: [[The State of Julia | JuliaCon 2021 | Stefan Karpinksi, Viral Shah, Jeff Bezanson, & Keno Fischer] ](https://www.youtube.com/watch?v=IlFVwabDh6Q) Since then I have seen a lot of talk and discussion about it as well as some attempt (StaticCompiler.jl) to address the missing feature of producing small binaries. I am asking about it because a lot of IT people around me are simply not interested in Julia because of that. I work in a large company and saw Rust and Go tak…

What I see in Schepper’s talk is that the two-language problem is a very real one at industrial scale. As a research software engineer and a scientist, this is also a problem that is persistent in academia across multiple domains. Real money is spent porting dynamically typed code to statically typed code. The person writing the dynamically typed code is often not the same person writing the statically typed code.

> [@anon56330260](#):
>
> - People seldomly rewrite their codes, see the Google’s paper I quote above. Because it incurs context switching and it’s costly to refactor codes, especially if your type definition is not well-typed. This is the innate limitation of human’s physiology and psychology.

A counterpoint to this is that it may not be a single person that writes their dynamic code and then rewrites it statically. The two or more people have to be able to communicate and need to have some comprehension of what the others are doing. While it is difficult and costly to refactor codes, some organizations have a strong interest in both producing research code and refactoring that code.

I have run into this situation across a number of languages recenty.

- Python / [Cython](https://cython.readthedocs.io/en/stable/index.html)
- Java / [GraalVM](https://www.graalvm.org/)
- Kotlin / [Kotlin Native](https://kotlinlang.org/docs/native-overview.html) / [Kotlin Multiplatform](https://kotlinlang.org/docs/multiplatform.html)
- Scala / [Scala Native](https://scala-native.org/en/stable/)

Developers have already accepted that not all Kotlin programs are going to be able to ported to Kotlin Native, but they still see utility in being able to build native binaries. For me, the outstanding question is “Can Julia offer a better experience than the above existing solutions or using two languages?”.

---

_[View the full topic](https://discourse.julialang.org/t/does-julia-create-a-1-5-language-problem/107984)._