I'm in a position of supporting a Julia environment but not writing Julia myself. From my perspective, they need to fix time-to-first-plot before it can be adopted more broadly. It's horrendous. The "2-3 minutes" I see online is an aggressive estimate; it's more than that for our modest set of data science packages on very beefy workstations. I had to use PackageCompiler.jl to build a sysimage which shifted a ton of burden onto me (and onto GitHub Actions) to avoid a long precompile on every user machine. I had to do the same to get my Julia Docker image to stop precompiling on every new cloud machine even though it had already been precompiled during docker build. I would describe this process as a nightmare, and it was a serious problem--the thing was precompiling every time on every job run in the cloud using the docker image.

It has on some industries, keep it steady and slow, eventually more people will notice it.

https://juliahub.com/industries/case-studies

Many languages could dream to have even a third of such high profile case studies.

Shame that it had so many nice ideas, but everything about Julia is half-baked at best.

I like to play with it, but just it.

> User-Extensible Rank Polymorphism is just beautiful with the broadcast dot syntax ...

Just to be clear, I guess that Julia's broadcast (dot) syntax is an implementation of "User-Extensible Rank Polymorphism"; is that right? Or does Julia's dot syntax include more than UERP?

I love working in Julia, it makes clean numerical code so easy to write.

Julia may be cool, but it's not an array language in the tradition of APL.

Not op, but I assume it means that there's rank polymorphism (i.e. data can be of arbitrary dimensions, and there's support for things like functions working on both N-dimensions, without having to specify n, or maybe setting constraints on n), and that the polymorphism can be used on the programmer side (so it's not limited to just a handful of language builtins) through the oop equivalent of subclasses and interfaces.

  schema do
    input do
      array :regions do
        float :tax_rate
        array :offices do
          float :col_adjustment
          array :employees do
            float :salary
            float :rating
          end
        end
      end
    end

    trait :high_performer, input.regions.offices.employees.rating > 4.5
    
    value :bonus do
      on high_performer, input.regions.offices.employees.salary * 0.25
      base input.regions.offices.employees.salary * 0.10
    end
    
    value :final_pay,
      (input.regions.offices.employees.salary + bonus * input.regions.offices.col_adjustment) *
      (1 - input.regions.tax_rate)
  end

  result = schema.from(nested_data)[:final_pay]
  # => [[[91_000, 63_700], [58_500]], [[71_225]]]

  Region 0: Office 0 has 2 employees, Office 1 has 1 employee
  Region 1: Office 0 has 1 employee

The programmer can define functions that operate on matrices without having to be explicit about the number of dimensions and possibly (types of data, size of data, or length).

Example 1: A function that can take as input a 4x2x8 matrix or a 3x7 matrix.

Example 2: A function that can take as input a 4x2x8 matrix and a 3x7 matrix and output a third matrix.

game math libraries often have this (and glsl gpu shader language), like "2 * vec3(1,2,3)" results in "vec3(2,4,6)"

There are other cases like adding vectors to matrices and so on, but in the end this logic is defined in some custom add operator overload on a class or object in the language.

(I had no idea what it meant either until i searched for examples..)

I wondered the same. Similarly I wish the author had provided examples for statements like

> Numpy also needs to be paired with a JIT compiler to make python a real array language

"Rank" means the number of dimensions of an array.

So "rank polymorphism" means being able to write expressions that work correctly regardless of how many dims the arrays involved have.

For example, in numpy you can write a function that handles both lists and matrices automatically, by taking advantage of broadcasting. (The J language takes this idea a lot further -- numpy is a fairly minimal implementation of the idea.)

It's just like polymorphism, only stinkier

Well, do you know how it works? Don't judge a book by its cover and all. Although none of these are entirely aiming for elegance. The first is code golf and the other two have some performance hacks that I doubt are even good any more, but replacing ∧≢⥊ with ∧⌜ in the last gets you something decent (personally I'm more in the "utilitarian code is never art" camp, but I'd have no reason to direct that at any specific language).

The double-struck characters have disappeared from the second and third lines creating a fun puzzle. Original post https://www.ashermancinelli.com/csblog/2022-5-2-BQN-reflecti... has the answers.

When the junior programmers start saying "Turing complete" or the academics build a DSL in Julia that uses RegEx to parse Logic Symbols and stuffs the result in variables that use ancient characters that don't appear on your keyboard, it's a sure sign of imminent progress. Bonus if the PhD with nine years of schooling and five months of PHP experience at Facebook starts using emoji in commit messages.

Array Programming is an acquired taste, but once you do, solutions can be extremely simple, both to write and to explain.

Think about using matrix to describe geometric transformations instead of using standard functions.

  [ cos(θ)  -sin(θ)  0  0  ]
  [ sin(θ)   cos(θ)  0  0  ]
  [ 0        0       1  0  ]
  [ 0        0       0  1  ]

It's giving APL: https://en.wikipedia.org/wiki/APL_(programming_language)

This type of syntax allows rapid iteration when looking at different implementations and experimenting with array problems. It should be thought of more as math notation than general programming.

I see it as beautiful the same way Galadriel would be beautiful as the Dark Queen. Utterly captivating and powerful, and yet something that should never be.

If I understand correctly what is meant by rank polymorphism, it is not just about speed, but about ergonomics.

Taking examples I am familiar w/, it is key that you can add a scalar 1 to a rank 2 array in numpy/matllab without having to explicitly create a rank 2 array of 1s, and numpy somehow generalizes that (broadcasting). I understand other array programming languages have more advanced/generic versions of broadcasting, but I am not super familiar w/ them

Unfortunely, while the community is great, what it doesn't have is a direction, thus keeps pivoting every couple of years, and with that lost the adoption opportunity window it had a decade ago.