
Functional calisthenics - pedromsantos
https://codurance.com/2017/10/12/functional-calisthenics/
======
maxxxxx
Isn't this going a little overboard?

I remember when OOP came up, some people made functions illegal. So instead of

s = sinx(x)

the OOP way was

m = new Math() s = m.sin(x)

And instead of switch statements you had to derive a new class for each case
call a virtual function. Very "OOP" but it led to the OOP equivalent of
spaghetti code.

Are the functional guys also starting to leave the real world for the sake of
being "pure"?

~~~
munificent
The article states:

    
    
        These rules are constraints on how to create your code
        and are only intended to be applied when doing katas or
        exercises.
    

These rules are an exercise to kick you out of an OOP mindset, not best
practices for writing real code.

By that same token, I think it _is_ a good rule when practicing OOP to not
allow bare functions. It helps train yourself to think "Is there a logical
class that this method belongs to?" In real code, of course, the answer is
often "no". But when first learning OOP, it's good to teach yourself to _ask_
that question in the first place.

Your code isn't a good example of "the OOP way", though. A fluent OOP solution
would be:

    
    
        s = x.sin()
    

Another good rule when practicing OOP would be "No classes without state."
That helps you avoid the habit of writing pointless "namespace" classes like
the "Math" class you define here. Of course, again, sometimes it is useful to
wrap a bunch of related behavior in a stateless class, but that should be the
exception, not the default.

~~~
michaelg7x
In Java static methods are a particularly simple way making clear to the
compiler and runtime that a given functions does not have side effects (to
instances of the owning class). I can imagine that, as a pattern, they would
assist escape analysis.

~~~
lederhosen
A static method can of course mutate an object of the same class (give the
object as an argument (direct or indirect) or use a static variable of the
class)

I can not see how they could be used to help escape analysis more than that
you have one less reference (this).

~~~
michaelg7x
Yes, of course that's possible. I was trying to point out their usefulness to
the programmer as well as potentially to the runtime/JIT. Next time I'll list
the obvious exceptions!

------
crimsonalucard
I wouldn't even call these things calisthenics. These are requirements for the
programming style to be called "functional."

Really if you aren't following < _Edit_ > Most < _Edit_ > of these rules you
are not doing functional programming.

The best way to learn about functional is not to follow these rules but to use
a functional language that basically enforces these rules. Javascript is not a
good language to learn about functional programming.

~~~
jw-
I'm not really sure why you need the requirement of infinite sequences to do
functional programming, or the restriction of no intermediate variables. Let
bindings seem like a nice thing to have.

~~~
crimsonalucard
No you're right. I missed the infinite sequences thing. I'm going to reword
the post from "all" to "most"

------
gaius
I came here expecting an article on CrossFit!

------
CJefferson
I don't understand "no explicit recursion". How do you do any kind of binary
tree search without recursion?

~~~
MiyamotoAkira
The people that talked about the rules at Codurance was none of the people
that defined the original rules. We had to "reverse engineer" the thinking,
find reasons and then discard, change or let as they were (one of the
objectives of the write up was to put down those reasons). Explicit recursion
did take a while. The reasoning we came with is to learn to use map/reduce
functions (do take into account that our group has an ecletic knowdledge of FP
and hybrid languages: Clojure, Haskel, Elixir, Scala, F#, ...). Can that
binary search tree be converted into a linear search if you rearrange the tree
into a list? Yes. Now you can use map /reduce. Is it performant? Most probably
not. Are there other ways? Time to discover. Interestingly, most of the
katas/exercises on which we are practicing these rules are not heavily
algorithmic in nature. Maybe we do need to add some to understand better and
modify the "rules" with the new knowledge.

~~~
CJefferson
If you want an example, consider writing a simple recursive sudoku solver,
where at each location you fill in one empty square with the values 1-9, and
reject early if you ever have a repeated value in a row, column or box.

This is easy to write in C, and I always imagined would be something
functional programming would excel at, but it doesn't seem to fit with your
rules.

~~~
MiyamotoAkira
SOLD!!!!! I will have to add this to my kata collection. That also reminds me
of the 8-queen problem. The last solution that I created (C#) years ago did
use recursion.

