Thanks for taking the time to write this, it feels validating because what I said came from the school of hard knocks! I agree with everything you stated. And a

Thanks for taking the time to write this, it feels validating because what I said came from the school of hard knocks! I agree with everything you stated. And also very much appreciate the insight about the anti-pattern of using primitives to represent domain ideas. I hadn't considered that, because most of my day jobs have been about getting anything at all to work and putting out fires. I didn't know about Gary Bernhardt or functional core, imperative shell. Here are some more breadcrumbs I found: https://github.com/kbilsted/Functional-core-imperative-shell/blob/master/README.md https://github.com/kbilsted/Functional-core-imperative-shell... http://www.javiercasas.com/articles/functional-programming-patterns-functional-core-imperative-shell/ http://www.javiercasas.com/articles/functional-programming-p... https://news.ycombinator.com/item?id=18043058 https://news.ycombinator.com/item?id=18043058 https://news.ycombinator.com/item?id=34860164 https://news.ycombinator.com/item?id=34860164 https://news.ycombinator.com/item?id=12604767 https://news.ycombinator.com/item?id=12604767 I think of monads and promises/futures like imaginary numbers. We use them as placeholders, but they're difficult to reason about without executing them, which defeats most of the point of functional programming. That our goal is to connect inputs and outputs by way of some transformation that lets us treat the input-output pair and the computation as equivalent for substitution. Which opens up a host of possibilities around automatic optimization, parallelization and memoization (caching) which imperative programming mostly denies us. I believe that the world's reluctance to embrace this stuff has quasi-political undertones similar to academics vs application in the real world. In FP, I've noticed a certain dismissal of beauty/elegance as something subjective where it's assumed that developers can just simplify everything in their heads like in mathematics. The form of the solution doesn't really matter as long as it's functionally equivalent to another. Which tends to cause steep learning curves and a fondness for lingo. It's almost as if development time is meta and irrelevant, like developers have unlimited time budget to fully flesh out the domain solution, and the design scope will never change. Whereas in IP, there's this sense that code doesn't matter, only the user experience does. The backlog is infinite, there is always zero time until deadline so developers are always behind, and design scope is a moving target. Attempts to formally architect the domain solution are viewed as over-engineering, or waterfall instead of agile. Readability, comments and documentation often dictate the success of projects more than shrewd architecting. I would say 50-90% of my workload today is fixing other developers' unforced errors. I'm concerned mainly with how future-proof the code is. Which usually comes down to some very simple constraints which I can't apply because they aren't available. Like, most IP languages don't have const, or don't have it for data structures. Or constness is an add-on that often breaks the caller like in C++, and isn't on by default. Or keywords like final exist in the language because the compiler doesn't manage the arrangement of fields in data structures. Or multiple inheritance doesn't exist for similar reasons, putting the work of dealing with the limitations of interfaces and traits onto developers. Anymore, I feel like pretty much any IP language creates more work for me than if I had just created the app in something like HyperCard, Filemaker, Microsoft Access, a spreadsheet, or even a database with stored procedures: https://sive.rs/pg https://sive.rs/pg Where I'm going with this is that I don't quite honestly know how much longer I can keep doing this. Programming has become a penance. Nobody in power seems to care about fixing the status quo. If anything, the complexities of "modern" software engineering create barriers to entry that benefit established players. So even though I know just exactly what an FP core, IP shell language would look like and how it would be tested with behavior-driven development (BDD), I may never have the time to build it, so it may as well never exist. To preserve sanity, it's often safer to pretend that better ways are a fantasy, and just keep focusing on survival. Hope is a dangerous thing, hope can drive a man insane, as Red said in Shawshank Redemption. So instead I evangelize and influence, and wait for the world to manifest it. Which hasn't happened in the 25 years since I got serious about disruption. If anything, it's all gone the opposite direction from what I had hoped for. It's looking like we'll end up with imperative core, AI shell. Which will bring about the end of (profitable) human software engineering as we know it, when code becomes too complex for us to reason about, but approaches free. Which is looking more inevitable with each passing day. And really has me questioning why I got into programming in the first place. I thought I'd have more time.