Is it wrong to call Julia interpreted?

General Usage
83

Just to add one more thing to this, I’m remaining pretty steadfast in my opinion that it is neither technically wrong to refer to Julia’s implementation as interpreted, nor is a technical definition the one that actually matters.

  • It’s not technically wrong because Julia has an interpreter which is always in the background, and you can execute quite a lot of code in that interpreter, although some things need to be compiled as well. In fact, it is the presence of that interpreter that facilitates the features I’m speaking about. The interpreter is actually very important for this reason—not because it’s where your loops are running, 'cause it ain’t (usually).
  • The technical distinction is the wrong one to focus on because the common usage of this term has nothing to do with execution strategy. For practical purposes, the old technical definition of “interpreted language implementation” is dead. No general purpose languages work this way. In common usage—according to my experience, “interpreted” is used to refer to languages with certain features (primarily based around runtime eval), and these languages use many different implementation strategies to to achieve this effect.

Now I’m wondering how people would feel if I started calling Julia a “runtime eval’d language with JIT compiler”. JAOT, for me, is not really related to what I want to say with “interpreted” because I’m not using the word to speak about the implementation strategy, but rather the host of features that runtime eval facilitates—including but not limited to interactivity. The shortcoming of “interpreted” is that people may infer something about implementation strategy that is not intended, so this can be a problem.

I think the notion of runtime eval really captures everything I want to say with interpreted—the only shortcoming of this verbiage is that nobody talks like this. The two likely possibilities are either

  1. People will think I’m simply referring to the presence of the eval operator, which doesn’t really capture the richness of the paradigm I’m talking about. I rarely use eval, but I frequently take advantage of Julia’s ability to evaluate code at runtime.
  2. Other people will think it refers to the implementation strategy and think I’m talking about a line-by-line interpreter, even if I don’t use the word “interpreted”.

It seems all words are subject to misinterpretation. It’s a problem.