beware the gifted son to burnout puppygirl pipeline

I love keeping up with new game releases and especially indie games, but omg I am so tired of all of these emotionally gripping story-oriented games - especially when the underlying gameplay looks fun. I’m not sure if this is becoming more of a trend over time but I feel like 80-90% of new games that I hear about are all story-oriented, and the remaining 10-20% are indie games that often don’t catch my interest at all

I’m starting to think that in order to really grok functional programming you need a certain kind of brain. the kind that doesn’t just understand math but enjoys doing it

and like I understand that the philosophy is to maximize the use of pure functions and to program declaratively. but I’m not sure if I’ll ever understand why certain people value those things so highly that they’d go out of their way to use languages that are designed to support them. especially the languages like Haskell that don’t support any other style of writing your code

I was hoping that trying functional languages would make this more clear to me but unfortunately I think all of my experience in imperative scripting languages is getting in the way, because every time I struggle to do something basic in E.G. Haskell all I can think about is how easy it would be to do in Python instead. but that’s because I’ve been using Python for 20 years and I’m very bad at math - so it’s not a fair comparison

at least to me as someone who was taught to hate math in school, it feels like programming a nontrivial function in a functional style gets arcane very quickly. it’s like you have to solve a difficult math problem in your head in order to figure out what code to write, and then when someone else reads it they have to re-solve the same math problem in their head in order to understand how your equation works. and I’m not sure if it’s supposed to feel like that or if that’s just me being bad at math again

maybe if someone is learning programming for the first time and they really grok math, it feels the other way around for them? like imperative code takes a lot of mental energy, but functional code is effortless to read?

I guess I feel like - if I was ever going to understand the appeal of functional programming - I would have by now. I’ve read so many “why learn this functional language?” chapters at the beginning of different books, that talk in vague terms about how the language is pure or elegant. but for me everything is so much harder in functional-land and I’m not sure if it’s supposed to be harder or if it’s actually easier for those who grok it

I’ve been thinking about the concept of pure functions a lot lately. at first I wanted to dismiss them but knew that I didn’t have enough experience with them to really make a judgement, but now I think that I’ve tried them enough to be able to give my thoughts

so first of all, pure functions are useful because they can be easily tested as self-contained code, which makes both debugging and unit-testing easier

but, I would argue that a codebase full of thoroughly unit-tested impure functions is actually much easier to debug than a codebase full of non-unit-tested pure functions. simply because you can immediately rule out all unit-tested functions as the cause of the bug (unless the unit-tests are missing something important, which I’ve never run into personally)

pure functions are very easy to unit-test, but impure functions with simple and well-documented side-effects are roughly as easy, and IMO they tend to be much more ergonomic overall: they’re generally easier to write, read, understand, and use (assuming that this is a function where one would be tempted to have side-effects, of course)

the one exception to this IMO is when you’re mutating shared state that isn’t neatly contained inside of an abstraction like an object. for example if a function takes a data-structure and then mutates that data-structure, you have to trust the caller to know that it’s okay for all references to that data-structure to be mutated. but in that case my solution would just be to make a class for that data-structure instead. because then it’s much easier to conceptualize what that state represents, and when it’s appropriate to make a copy of it instead of changing the original

I feel like there are plenty of potential footgun situations for a caller thinking that they have the only reference to some data-structure, mutating it, and then realizing that some code somewhere else was relying on the same assumption (that they have the only reference to that data). but again I think that the best solution is often just to make a new class to hold the data instead of treating the data itself as immutable

so basically I think that limiting the un-abstracted complexity of a function’s side effects is often a very good idea. but I think there are diminishing returns to limiting side-effects, and trying to maximize the number of pure functions in a codebase is more trouble than it’s worth - both for the caller and for the function-writer