Getting stuck in their review / re-categorization process sucks. It’s not transparent, can take awhile, and often the outcome (their choice of category) doesn’t make sense. My experiences were primarily in optics and physics, with a bit of ML.

I wonder if the moderators are somewhat disconnected from the communities that they are moderating. Or, at least, if they are active researchers maybe they aren’t fully aware of all the trends in certain sub fields their area covers.

JAX looks really interesting but it seems that it’s not as straightforward to just JIT things. Generally I think you need to use their flow control mechanisms rather than standard Python ones. There are of course technical reasons for doing so, but this makes me wonder if languages like Julia with packages like Zygote.jl would be nicer for some situations in the long run.

With JAX you _can_ just use python control flow with gradients, so long as you don't try to jit-compile the control flow. This ends up being just like PyTorch / eager execution. However, you have the option of compiling the largest possible blocks of code that are convenient.

When writing code in JAX, I often start by write code eagerly and then try to jit increasingly large pieces to get more performance.

You might also find the experimental control flow interesting since it tries to be more pythonic while also being possible to jit-compile. (https://github.com/google/jax/blob/master/jax/experimental/l...)

I agree with this. I believe the choice of having them as macros rather than functions was made for performance reasons? However, I think they should be in std lib... having to do 'using Printf' everywhere is silly

I once spent a bit of time playing with DataFramesMeta.jl, which is what I was able to find that seemed like Julia's answer to dplyr, and I thought it was awful precisely because everything was macros. With dplyr, any function that takes a dataframe and returns a dataframe can be thrown into the mix. In DataFramesMeta.jl, if I ran a chain of events and needed to look at only the first few rows, instead of throwing Julia's head function into the chain I was building, I had to switch modes and wrap everything in the function. It was aggravating (and yes, this is a very minor thing, but I was only doing very minor work, and as things got more complicated I don't think I was going to miss dplyr's flexibility less).

I think this post is pretty outdated... Julia has come a very long way since v0.4.

This package is the engine for the results of a paper that we just posted to arxiv (https://arxiv.org/abs/1904.12831).