Why am I fascinated with functional-programming, denotational-semantics, denotational-design, type-driven-design, etc?
Is it just because I’m more interested in more-reliable software? No.
Is it because I want easier-to-read, faster-to-change, more-flexible software? Almost, but not quite.
Rather, I feel that it’s because I want to preserve *meaning* in software, because that is the only thing of value. And I define meaning as relationships defined within a context. For a function, the meaning is the relationship between input and output, and the context is the type of the function.
Only by preserving “meaning” have we preserved the specification of the program, in a fine-enough grain to be reusable.
Haskell seems to me to be the language that best enables writing meanings of aspects of a program down in a concise, specification-oriented notation, in immutable rules about the system. Writing these meaning-relations as invariant-constraints (which I just called “immutable rules”) enables building systems that do not need to change radically when some small aspect of the environment changes.
This seems like a very important step for software to take, if we want to stop spinning our wheels in the IT world, reinventing the wheel thousands or millions of times, and move up the layers of abstraction toward truly flexible, and perhaps even slightly “intelligent” software.
Demos from StrangeLoop of live-programming environments seem quite relevant to this process of implementing abstractions in a functional-programming-language such as Haskell, because such demos seem like they would be in some cases almost trivial to implement with a model such as FRP. (A possible example is https://www.youtube.com/watch?v=i3Xack9ufYk … but the video about Eve by Chris Granger may be a better example.)