Ryan Peterman

You have to be like, no, I need to look up and check, did the user redefine this?

I think it's brace and not parenthesis, but it's been a while, so I haven't dug in.

But it may also be parenthesis, or it's possible I flipped them.

We can check offline and see whether my memory is good.

But you just wind up with so much stuff like this that is so like,

may be changed, and you don't know whether it changed.

So you need to go check whether it changed.

And the checks are very expensive, especially if you're doing something like adding two 64-bit integers.

That's like one machine cycle.

It is one machine cycle.

But a check, does addition still mean what I think it is?

Could be hundreds to thousands of machine cycles.

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?