...and you thought it was hard to find people who could understand OO.
FP is moderately difficult to understand and hard to do wrong.
FP is the pwn sauce, no question. The more interesting debate (and one on which I don't have enough experience to have an authoritative opinion) is the static-vs.-dynamic controversy.
There is own "pwn sauce" -- there are just fads.
Static vs. dynamic typing, on the other hand, involves a decision about the language that has to be made early in development. Lisp's static-typing support sucks in comparison to what Ocaml or Haskell provide (automatic type inference, which kicks ass, and very powerful type systems). Likewise, if you want dynamic typing in Ocaml, you have to create a universal type: there are ways of doing this, but they're gnarly and slow.
I've often wondered about how to build a hybrid language. A possibility would be to implement a language like ML or Haskell (but keeping the S-expressions, because those are awesome despite their unpopularity) as a DSL within Lisp, heh. Now that would be the pwn sauce.
i tried erlang, but really, my mind prefers thinking in lisp :(
do i miss a lot not learning other FPs?
to me python seems emphasizing more on OO than FP; lisp is the reverse
Apparently Haskell also has some support of dynamic typing.
I know the "typed lambda calculus" is the super set of the lambda calculus, but that's about it for me (or rather the "commonly known" lambda calc. is really a special case of the more general typed lambda calculus) - now if that translates into static typing being more mathematically pure/complete, I don't know (and even if it did - what does that mean in practice??).
I think nice languages with decent type systems kind of make static typed languages look nice - so the aesthetic argument (which is what most people refer to when they bring up the debate) mostly goes away (eg haskell, scala to some extent - although it can get gnarly).
I like using both - however from what little experience I have had I haven't enjoyed dynamic languages with optional type annotations (but it is limited experience).
I am interested in Brendan Eich's suggestion for ECMA script 4 (!) to have typed interfaces for the edges of a system....
There are, likewise, functions and tools that can't be built in statically-typed languages. For example, a general "compose" function (or macro, if you're so inclined)-- one that takes a list of functions and produces their composition-- can't be built in a language like Ocaml. (The best you can do is ('a -> 'a) list -> ('a -> 'a) ; e.g. it has the additional requirement that each function have the same return type as its input.)
As well as the ones you mention - would you include IDEs etc ? or is that more an issue of not doing the "smalltalk way" of editing running code?
For example, let's say you change the output type of a function deep in the trunk-- instead of returning a 'a or throwing an exception, it returns a 'a option, e.g. a discriminated union between None or Some x, where x is a 'a, using the None value to represent failure, in lieu of the exception-- and want to find all the places where things break in the leaf code, so you can adapt them to the changes. What tool do you use: grep? Nope. You attempt to compile the tree, and all the code-breaks are caught and displayed by the compiler.
For instance, I would say for OO two benefits that can create an order of magnitude increase in a programmer's performance are: - much easier to use 3rd party libraries(since most good code is OO) - much easier to modify/debug code
1. Concurrency done right -- take a look at Erlang or Clojure to get an idea of multi-threaded programming without the nightmare of locks and deadlocks. This feature will become increasingly important as CPUs are scaled by integrating more and more cores.
2. Testability -- immutable variable bindings and carefully sequestered state changes means your code is vastly better suited for testability.
3. Distributed Computing -- this maybe a controversial claim, but in my experience building distributed systems in Java, Common Lisp and finally Erlang (on separate projects of course), Erlang stood out as the most robust and understandable distributed model of all.
In so far as 3rd party libraries go, a lot of newer FP languages are built on top of existing VM platforms (e.g, Clojure on JVM, F# on .NET), and are able to leverage all their available libraries. Bear in mind, that while these libraries may help build your application slightly more quickly, you end up sacrificing the benefits of FP by integrating their non-FP code.
Check out http://www.defmacro.org/ramblings/fp.html for a much better overview of FP (don't miss the "Benefits" section about a third of the way in).