I just don't understand comments like these. Providing a blanket statement that doesn't provide any reasons whatsoever. It doesn't really help contribute to the post, and it just angers people. I hate the term troll, but that's what this feels like. If you actually feel this way then I feel bad that you restrict yourself to only one type of tool. Also I find it confusing when functional evangelicals talk bad about OO and mutable languages when a lot of the languages compilers are built on languages like C. They wouldn't even have functional languages without C.
While Haskell's (well, GHC's) runtime does have parts that are written in C, GHC itself is written in Haskell (and was originally written in a ML dialect I think). The lineage of FP languages seems to be very different than whats typical.
But yea, random blanket statements like that aren't helpful.
There is an older Lua backend for PureScript (at https://github.com/osa1/psc-lua) that may be worth checking out... if it gets a revival. AFAIK that version is a superset of (current) Elm, so it may be possible to combine it with love to get some sort of "Elm for love2d" :)
> They wouldn't even have functional languages without C.
The functional paradigm is, as are some language families in which the use of the paradigm is idiomatic (esp. the Lisp family), older than (or roughly contemporary with and independent of, as in the case of ML) C. So, no, this is clearly not the case.
You don't understand comments like this because you probably don't speak from years (20+) of programming experience in OO languages, like I do, and because it is hard to show people certain better ways of doing things that unfortunately requires years of experience beating your head against the wall in other ways to really see it. But don't take my word for it, here is John Carmack (hardcore C++ developer) on the topic, from this link: http://gamasutra.com/view/news/169296/Indepth_Functional_pro...
"My pragmatic summary: A large fraction of the flaws in software development are due to programmers not fully understanding all the possible states their code may execute in. (Emphasis mine. That alone explains most of the bugs I've seen.) In a multithreaded environment, the lack of understanding and the resulting problems are greatly amplified, almost to the point of panic if you are paying attention. Programming in a functional style makes the state presented to your code explicit, which makes it much easier to reason about, and, in a completely pure system, makes thread race conditions impossible...
"No matter what language you work in, programming in a functional style provides benefits. You should do it whenever it is convenient, and you should think hard about the decision when it isn't convenient."
This is a man who has coded slightly longer than I have, and IMHO he is correct on all these points.
I merely believe he didn't go far enough (for example, immutable "variables", which are not available in OO languages without hairy workarounds, ENSURE that the state your code "sees" is not tampered with "from the outside," further reducing bugs), but statements like this are why I take the viewpoint I do.
Take the amount of time you debug as a percentage of your total programming time (and hell, we all enjoy debugging to a degree, don't we? But what's debugging, really? All it is, is trying to discover a state that wasn't conceived of when the code was designed, no? That's the whole point of your stack trace, right?). Now, chop that time in half. Would you want this? Who wouldn't?
Yes, FP is not appropriate for all realms where code lives. But it should most certainly fill all the spaces it currently does not, where its appropriateness is not out of the question.
I would also strongly recommend the "Are We There Yet?" talk by Rich Hickey http://www.infoq.com/presentations/Are-We-There-Yet-Rich-Hic... which pretty much destroys mutability as a language-level trait, pretty much rendering it the mother of all bugs (literally).
This is why I get upset whenever a new language comes out that does not feature FP/immutable paradigms. If you're new, you SHOULD be using these, otherwise you're just perpetuating more man-years of debugging hell for people. I am tired of watching new programmers make the same mistakes over and over and over again.
The very length of this comment alone indicates how hard it is to communicate this AND why it sounds like preaching/proselytizing/trolling.
