John O'Neill
3 HN recommenders · recommended in 4 months, 2017–2023
1:21:39 · 865 views · Mar 2, 2016
Jan Vitek of Northeastern University gives a meetup talk on the challenges of making the R language run fast. He explains what in R's semantics makes it hard to optimize and to build a JIT compiler for.
HN points to it as the best explanation of why R is so hard to optimize, often paired with talks on Python and used to explain what makes Julia fast.
4 comments from Hacker News
Perhaps the best way to understand what makes Julia fast is to watch these two videos about Python and R and what makes them so hard to optimize: [LINK] this video Take everything mentioned in these videos that make Python and R really hard to optimize and don't do those things :D
I recommend watching this video - Making R run fast this video It's a little disappointing, because the conclusion is that R will probably never "run fast", but very interesting nonetheless.
Another talk on the difficulty of optimising R is this fantastic one by Jan Vitek: this video Also, my favourite R trick: foo <- function() {rm(foo, envir=environment(foo))}
This is disregarding the development of said ecosystems though. The point is that Python has been quite inhibitory to the development of this ecosystem. There are many corpses of automatic differentiation libraries (starting from autograd and tangent and then to things like theano to finally tensorflow and pytorch) and many corpses of JIT compilers and accelerators (Cython, Numba, pypy, and TensorFlow XLA, now PyTorch v2's JIT, etc.). What has been found over the last decade is that a large part of that is due to the design of the languages. Jan Vitek for example has a great talk which describes how difficult it is to write a JIT compiler for R due to certain design choices in the language ( [LINK] , or the more detailed version this video ). There are certain language constructs that void lots of optimizations which have to then be worked around, which is why Python JITs choose subsets of the language to avoid specific parts that are not easy to optimize or not possible to optimize. This is why each take a domain-specific subset, a different subset of the language for numba vs jax vs etc., to choose something that is nice for ML vs for more generic codes. With all of that, it's perfectly reasonable to point out that there have been languages which have been designed to not have the compilation difficulties, which have resulted having a single (JIT) compiler for the language. And by extension, it has made building machine learning and autodiff libraries not something that's a Go