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.

1. No Assignments.
2. No Varying Your Variables. (Immutable)
3. No While/For Loops.
4. No Control Over Order of Execution. 
5. No Side Effects.
6. No Mutating or changing state.

total = 0
i = 0
while i <= 10
  total += i
  i = i + 1
end
total

 total = (1..10).inject(:+)

add = proc { |x, y, z| x + y + z }

add5 = add.curry.call(5)
add5and6 = add5.call(6) # equal to add.curry.call(5).call(6)

add5and6.call(10)  # => 21

 def factorial(n)
   if n == 0
     return 1
   else
     return n * factorial(n-1)  
   end
 end 

 def factorial_one(n, total)
   if n == 0
     return total
   else
     return factorial_one(n-1, n * total)
   end
 end

 def factorial(n)
   return factorial_one(n, 1)
 end

1. Lock Free Concurrency.
2. Brevity. (Modular Code)
3. Lazy Evaluation.
4. Composability.
5. Parallelism.
6. Improved ways of Testing.
7. Referential Transparency.
8. Lesser Bugs.

1. Steep Learning Curve.
2. Cryptic Concepts (Monads)

1. Clojure
2. Haskell
3. Erlang
4. Lisp
5. Scala
6. Scheme
7. F#
8. OCaml