Why I still recommend Julia
The example using Measurements.jl only works as a good example for composibility if you use `Number` as the type for the argument. If you happen to use Int then it doesn&#x27;t work:<p><pre><code>  using Measurements
  plus_one(x::Int) = x + 1

  plus_one(measurement(1))
  ERROR: MethodError: no method matching plus_one(::Measurement{Float64})
  Closest candidates are:
    plus_one(::Int64) at REPL[2]:1
  Stacktrace:
   [1] top-level scope
     @ REPL[3]:1
</code></pre>
This is perhaps my biggest annoyance with Julia. Concrete types cannot be subtyped, and hence cannot be extended by other packages. And explaining to researchers and scientists that they need to use abstract types to make their code more composable is exercise in frustration. I think computer scientists with experience programming in C++ may have good intuition for when to use concrete or abstract types in the function signatures, but research scientists in ML and optimization (in my experience) just don&#x27;t do a good job of that. And just end up having awful Julia code to work with, that isn&#x27;t really extendable. In my opinion, readability suffers greatly when you have to understand the type hierarchy in order to find out if your code will MethodError or not. For example, if the author use `plus_one(x::Rational) = x + 1` instead of `plus_one(x::::Number) = x + 1`, would the code that uses Measurements.jl have worked? Who knows just by looking at the code. It turns out it doesn&#x27;t work and there&#x27;s a MethodError. The built in type hierarchy is great, but third party packages are hit and miss.<p>Honestly a simple solution to this would be to allow concrete types to be supertypes of other types. My understanding is that there&#x27;s no compiler related reason for this, and this is just for &quot;good practices&quot; but for the life of me I don&#x27;t understand why this limitation was made. I&#x27;ve seen Julia code that creates a supertype abstract type for every concrete type they create, and it is just awful to deal with. Fortunately, it is somewhat easy to write a macro to make this happen, but still very annoying that one has to do this at all.<p>Combine that with the lack of a file system package modules (like in Python or Rust), the lack of any kind of doctests, the built in testing being so lackluster, you end up with really poorly organized code.<p>TSCoding has a 1 min video on why he doesn&#x27;t program in Haskell anymore [1] and I can&#x27;t help but feel his reasons directly apply to Julia too.<p>For example, in order to run that example for this comment, I had to run `add Measurements` and it took 7 minutes to download the package. Why is the &quot;registry&quot; for packages in Julia a giant git repository? It takes SO long to update every time. This is an example of a poor software engineering decision in an otherwise elegant language.<p>[1] <a href="https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=SPwnfSmyAGI" rel="nofollow">https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=SPwnfSmyAGI</a>