[leoff]

Interesting how the post doesn't mention the word "side effect" once.

To me, all of this could be summarized by "no side effect".

[tromp]

He didn't need to mention it because it's implicit in data flow. Instead of the side effecting / state changing

    whip(cream)

that needs to be under flow control, you have

    whipped_cream = whip(cream)

describing the flow of data. Data flow describes the relationship between non-changing entities and thus there are no side effects.

While they could have mentioned it, it wouldn't really change the message.

[BoingBoomTschak]

Similar reaction, I searched for "lambda calculus" first thing first and was pretty weirded by the "0 results".

To me (someone who really doesn't like FP as a religion), FP is about function application: everything should just be "pure" function calls taking values (not references) and returning values; immutability is indeed a corollary of that, static typing really isn't (isn't Church's original LC untyped, btw?).

[mrkeen]

Maybe the author was trying to avoid potential fallacies that follow that phrase around though:

* If you don't have side effects, you can't do anything.

* Haskell can do things? Then it has side-effects, so it's not functional.

* Computer getting hot is a side-effect.

* i++ is not a side-effect, because I intended to do it.

[_xiaz]

No, as in zero, (side) effects means no program for most domains.

For me, the essence of FP is the minimization of global state

[Feathercrown]

I think the point of the article is to illustrate why "no side effect" is important.

[magicalhippo]

While I agree, you can get all of that FP example from the article in say C++ by liberal const-usage. So is "const-y" C++ functional programming?

[mrkeen]

It's not enough to take out the 'bad bits' - you have to put in 'good bits' too.

For example, Java collections are mutable, but enough ink has been spilled about the dangers of shared mutable state, that there are various recommended defences, e.g. make defensive copies when you return collections to a caller. Or use one of the immutable collections that will throw a runtime exception if someone tries to mutate it.

Now consider if you wanted to evaluate 3 + 5. Should you throw an exception which tells the caller off for trying to change the value of 3? No, the caller just wanted 8!

This is what's missing with the 'just make things immutable' approach to FP mimicry. I want to be able to combine collections together. The Java standard library Set<> still doesn't have union and intersection for christ's sake.

[fhasdfyuasd]

I think liberal const-usage breaks move optimizations so it's not used in practice.

[magicalhippo]

Perhaps not these days, back in pre-C++11 days it was very liberally used. And something I miss in other languages, precisely because it allowed for much easier reasoning.

[blueberry87]

this is wrong! ocaml is a functional programming language with side effects.

[fhasdfyuasd]

To be fair, OCaml is multi-paradigm.

[blueberry87]

i mean, then we get into defining multi-paradigm :P does it have objects that could, theoretically, be used in a java-like object oriented system? yes! does anybody do that? not really! it's far more functional than any other paradigm, and that's what counts.