There’s so many of these beautiful ideas that collapse upon hitting the world in which we live. The paper makes these assumptions over and over again, that we can create and destroy things, “just like in the material world”, unfortunately it comes crashing head-on to the the first law of thermodynamics, which states explicitly that we can’t, do just exactly that, creating and destroying things.
The cost exists in the material world, as it exists in the memory in which our programs live. Some people have explored this connection extensively, that connection between resourced based computation and logic. Lafont, for example, and understanding the subtleties of the following two words is important:
The fundamental laws of computation are commutation and annihilation.
If we’re taking the material world as a paradigm, there’s something really interesting that we can look at, linear logic(!), which lives at the core of optimal lambda reduction and seems to coexist with the rules of the natural world. I think there’s definitely a point to be made about looking at how the material world works, and what computation model best maps to that reality.
At least, we might wan to search for something that doesn’t goes straight against the first law of thermodynamics.
Hot take: One thing I could say about the creation and destruction of resources and computation. I think variables/arguments/bindings/clojures are a mistake, they should not exist at all in computation, and if I had to make a prediction, one day, they won’t. Accessing things by name is fundamentally flawed as a resource management mathematics, because it’s based on traditional logic which obfuscates resource consumption and duplication.
FILE * f = new File();
f.destroy()
f.append('c') // error
Names allow to cross the boundary into a world in which things can be accessed, instantiated or destroyed without being aware of the cost, or simply accessed after they have stopped existing, and this distance from how the world in which we live works might be an indication as to why it’s computationally inefficient and error prone. I think the reason why this whole paradigm(as opposed to another without bindings, like tacit programing) leads to needless amount of errors from operating on things that don’t exist, is that same distance.
Anyways, object instantiation/sharing/as-values is a nice idea, one that I’d classify as Mathematically elegant, thermodynamically fictional.