I am trying to understand the buzz about "functional programming". It sounds like using functions without modifying parameters, and no global side effects. This sounds old school to me. Anyone care to elucidate?
Partially it can be viewed that way, but functional programming can be viewed in a wider way. The go to language for functional programming, Haskell, is one of very few that implements functional programming as pure as possible.
First, order of evaluation is undefined, the compiler should be able to generate code that evaluate either way it considers the most efficient. e.g. if you do:
there's no guarantee whether x, a or b will be evaluated first. In fact, it's possible that none might be evaluated due to the next feature.
Second, it enforces lazy evaluation, i.e. an expression will never be evaluated until the time its value is required. e.g.:
if either `x + 1` or `z + 5` isn't immediately needed, they will be passed around as is, as an expression. Even better:
y = f (x + 1) (z * 5)
f a b = g (a - 1) (b / 5)
will also evaluate neither `a - 1` nor `b / 5`. But once you add:
y = f (x + 1) (z * 5)
f a b = g (a - 1) (b / 5)
g a b = a + b
all of those expressions will be calculated in one go, possibly at compile time depending on the values or at least curried to be the simplest expression ever. So instead of 1 assignment over 2 functions the compiler will only generate a single expression:
Last but not least, (almost) full type inference (since sometimes you still have to specify one as the generic candidates might be too generic). This is not really possible in imperative languages due to the types are implemented (Haskell's type system could be a language in its own).
Some bits of functional programming can indeed be stolen and have been stolen by many imperative languages, such as: list comprehension, first class functions, etc.