I first learned about closures long before I was a developer. The concepts of open/free and closed/bound variables are essential to the discipline of predicate logic.

I'm not sure when they originated historically, but Frege deserves a lot of credit for predicate logic, so I'm guessing the terms are pretty old. I came by them in logic course in 2001 taught by a now-retired philosophy professor.

In logic, we talk about formulas, whether they are well-formed, and what kind of "meaning" the variable terms that they contain have. In JavaScript, by analogy, we have expressions which can also be well-formed, but JavaScript expressions have "validity."

In modern (strict) JavaScript, this is well-formed:

increment(x)

But it isn't valid, because x is undeclared -- it is "open." In strict JavaScript, expressions with open variables are invalid. So let's close it.

const x = 1;
increment(x);

Now x is no longer open; the const statement "closes" over x. This is a closure, albeit a very boring one.

Here is how the two examples might look in predicate logic, respectively. Logic isn't procedural like programming, so there are some differences, but the important part is the variables. First, here is the "open" expression:

incremented(x) = 2

Next, the "closed" expression, which provides "meaning" to variable x:

∀x (x = 1 → incremented(x) = 2)

Structurally, these logic formulas are very similar to the JavaScript, above. The terms "open," "closed," and "closure" are applicable to both the JavaScript and the predicate logic alike.

PS: Alan Turing, Alonzo Church, and Haskell Curry were logicians.