#+HUGO_TAGS esoteric “life itself”
There are some principles which are useful for a programmer to realize.
There are deep connections between these and functional programming, math and logic.
First, biological life “assumes” permanent (immutable) molecular structures and atoms as being “eternal”, well, atomic “black box abstraction”.
Of course, neither Life nor evolution (being mere processes) assumes nothing, but these are properties of a stable-enough environment which makes Life (and evolution) possible.
So, yes, there is always an environment, which contains “all the previous results” (supposedly immutable) or what we call “stable intermediate forms”.
This, of course, is what your \[\Gamma\] in Natural Deduction is. It is also a global namespace of a language, which is also a well-defined (shared) /vocabulary, the set of previous results (theorems, lemmas and proofs) in mathematics. It is the same notion.
The axioms of mathematics are a bit of a different nature – they (at least ideally) capture, generalize and abstract out the universal properties of the shared environment (which we call Universe).
So, at the level of molecular biology, supposedly eternal atoms compose into molecules, including the DNA and mRNA, which represent “the data”, molecules into aminoacids, aminoacids into proteins, which then act as both “code” and “data”.
Everything is also partitioned, nested and layered (even within a cell), so we have individual specialized cells, tissues, organs, systems, etc.
The “a-ha moment” is that everything is evolved as if all the molecular structures (aminoacids and corresponding proteins) are (ideally) eternal and immutable and every enzyme acts as a “pure function” of its “inputs”.
Not just that, but an environment (nested “frames” of it!) is out there and the Universe (particular locality) is the “runtime” which “runs” the enzymes.
This is, of course, not an arbitrary coincidence.
Evolution is a “blind” “macro-level” process, based on what we call trial-and-error. It is essentially a long-term “contest” between more-or-less stable molecular arrangements (at this level).
The “contest” is due to the “hostile environment”, of cosmic rays, entropy and other factors of a particular “locality” which eventually breaks and “alters” some molecular arrangements (causing mutations).
It is due to the “struggle” with a hostile environment new arrangements (molecular structures) emerge, most of which are just “breaking”, but occasionally a very rare arrangement turns out to be more “robust” or had a new emergent properties. We call such event a “favorable mutation”, and these events, among others, drive the process of biological evolution at the molecular level. (A mutation must “spread” in a population and “outcompete the others” or at least sustain itself. It is a vastly complex process).
Anyway, the emergent properties (of the “basic building blocks”) which we can observe (and the linear structures being used) are “universal”, and the early LISP and FP guys, intuitively at least, feel or “knew” this.
There are also “emergent patterns”, most notable of which are the partitioned compartments we call cells (and various intro-cellular arrangements), and the penetrable only for particular entities cell-membranes, which, it seems, is another fundamental universal pattern, what our “interfaces” have been captured and generalized.
One more time, Life Itself is not imperative. If you think a bit you will realize it cannot be imperative in principle – it wouldn’t be stable-enough.
The imperative “model” (rather an ad-hoc set of tricks) of programming is just a mistake, a fundamentally wrong and flawed set of notions, like magic rituals, alchemy or astrology. It just does not work as intended (and never will in principle – your intermediate building blocks aren’t stable-enough).
Yes, yes, I’m writing this in “imperative” Emacs, and there is a Chromium window – an imperative artifact more complicated than a Boieng airliner, but…
Think for a second what a Boieng airliner is to a fruit-fly, or even a single bacteria. This is the level of robustness we want for our building blocks, and imperative simply won’t do it.
Again, the early LISP and FP guys intuitively knew this.