Ryan Peterman

And so you wind up swapping in things that are very inefficient.

places that you don't need.

And this is particularly, R is amazing.

There's this amazing paper by a couple of students and a senior professor named Jan Vitek, but it's about the design, called something like Evaluating Design of the R Programming Language.

And one of the things they look at is, especially R has an especially tricky thing, which is, unlike Python, R is also a lazily evaluated language, where the arguments to functions are not evaluated before you start the function body.

They wait until the function kicks off, and they just are passed as promised objects.

And what they look at is they look at, well, how often are these promises could have been eagerly evaluated?

And how often is the overhead of these promises worth it?

And their conclusion is 70%, or maybe more.

Maybe it's 90%.

I forget the numbers.

You basically have no reason you needed to do this.

Almost never do you need this.

But you actually pay an enormous overhead cost for having agreed to do this.

And a good example, let's say in Python also,

In Python, you can manipulate the symbol table using functions in the inspect module.

And so what that means is you can never be sure of what something's bound to.

You always have to be afraid and check.

And just sort of general, the lack of invariance, that's what makes a language fast.

It's like you have lots of invariance.