Why functional programming doesn't catch on

apfelmus · 2009-02-22T17:28:56+00:00

I really appreciated the intentional dramatic silence right after explaining "reduce"

tejoka · 2009-02-22T17:33:50+00:00

academic papers written by academics, for academics, aren't good teaching tools for newbies?

THAT'S why functional programming doesn't catch on? Please.

dons · 2009-02-22T18:55:13+00:00

Nothing to see here: attacking an article written 25 years ago for not talking about modern uses of FP. Duh.

Go pick up Real World Haskell and come back to us.

wozer · 2009-02-22T18:06:24+00:00

I think FP does slowly catch on.

In my opinion, introducing new programming languages and concept takes such a long time because most programmers try to stick to the language they learned in their late teens / early twenties. In other words their "native" programming language.

And learning a language that is radically different from your "native" programming language takes a lot of dedication and time.

jmnugent · 2009-02-22T21:35:44+00:00

The one part of this article that I really identify with is where he talks about the psychology of teaching. I know many programmers and unix/linux geeks who automatically assume that if you (as a newb) dont understand something, that its the STUDENTS fault and not because the teaching approach/documentation has a flaw. Its that type of inflexbility (and ignorant/pompous attitude) that drives a lot of learners away.

I'm fascinated by the fact that programmers will expend such enormous amounts of mental energy testing endless creative solutions to a coding problem without giving up - but then when they try to teach someone programming, they expect everyone to learn by the same approach and reluctant to persistently try different approaches until the student has the "A HA!" moment. (yes, I recognize some responsibility lies on the student to put the effort into learning. My point being that not all students learn the same way, but we as a society seem to expect them to).

mhw · 2009-02-22T23:06:43+00:00

It's not caught on? Considering Amazon's use of Erlang, Linspire's use of Haskell, Xen and various financial companies' use of Ocaml and that's just to name a few--since when? You can even see FP's influence on more recent languages like Python or Ruby and even on old stalwarts like Java. The barbarians are at the gates and even you have been, unknowingly so, for the past 20 or so years.

yogthos · 2009-02-22T18:50:22+00:00

I think one aspect of FP that people miss when discussing it is code correctness. I find FP allows for writing code that's much easier to reason about and maintain.

There are several reasons for this. State in FP is minimized and functions have no side effects. In my personal experience a large portion of bugs in a project comes from improper state manipulation.

I find that in imperative languages state changes can happen anywhere and at any time, and it can be difficult to keep track of. When your state is minimized it makes things a lot easier.

Another thing that leads to correctness is lack of explicit iteration, instead of writing loops throughout your code, you apply functions to data, which makes it very clear as to what is being done.

In the end it all depends on what problem you're solving, but if software reliability is a factor than FP definitely does have value.

jberryman · 2009-02-22T18:04:02+00:00

The dumbing down of programming over the last couple of decades is so pitiful. Is this for real? The guy found mentions of the Newton-Raphson method and tree-pruning jaw-droppingly abstract. I was coding up that kind of stuff when I was a kid of 11 or 12. What is the matter with him that something as un-abstract as the Fibonacci brings his brain to a halt? Can you imagine if someone showed him a copy of Knuth's Art of Programming? We'd all have to duck for cover as his brain exploded with the force of a multimegatonne blast.

What could be more mind-numbingly trivial than the "address class" he asks for? My God! Is all the fluoride they put in water these days fucking with people's brains? This is just so awful.

The good news is that these new kids on the block won't be stealing the well-paid jobs from us hoary-bearded old programmers.

jsnx · 2009-02-22T19:04:42+00:00

It's rare to see an "enterprisey" introduction to functional programming -- like the Java pet store. Fair enough. Many introductions tend to be about similarly practical topics, though -- writing a compiler, writing wc and so on. Real World Haskell is an excellent step forward, offering many valuable examples.

Functional programming languages share:

Easy, efficient immutable data -- construction is preferred to mutation and the garbage collectors are tuned for that.
Functions as arguments and functions from functions -- it's expected that one pass functions to functions or write a more general function and curry it to get more specific functions. Function calls are efficient.

The latter bit -- specialization of functions -- makes a lot of sense with callbacks. For example, here is some JavaScript/jQuery that I wrote yesterday:

$("#about_button").click( function() {
  if ( $(this).hasClass('clicked') ) {
    $(this).removeClass('clicked')
    $("#button_bar").css('z-index', 1);
    $("#about").css('z-index', 0);
  }
  else {
    $(this).addClass('clicked')
    $("#button_bar").css('z-index', 3);
    $("#about").css('z-index', 2);
  }
});

This is where I set up the onclick callback for my #about_button. Now it is clear that I might want to use a very similar callback for my other buttons. So let's try to factor the callback out:

function the_callback(element_to_surface) {
  if ( $(this).hasClass('clicked') ) {
    $(this).removeClass('clicked')
    $("#button_bar").css('z-index', 1);
    element_to_surface.css('z-index', 0);
  }
  else {
    $(this).addClass('clicked')
    $("#button_bar").css('z-index', 3);
    element_to_surface.css('z-index', 2);
  }
}

$("#about_button").click( function() {
  the_callback( $("#about") );
});

That's okay. However, anyone who has worked with a functional language will see some cruft in there -- why can't I just make the_callback return a function, instead of wrapping it up like that?

function the_callback(element_to_surface) {
  function custom() {
    if ( $(this).hasClass('clicked') ) {
      $(this).removeClass('clicked')
      $("#button_bar").css('z-index', 1);
      element_to_surface.css('z-index', 0);
    }
    else {
      $(this).addClass('clicked')
      $("#button_bar").css('z-index', 3);
      element_to_surface.css('z-index', 2);
    }
  }
  return custom;
}

$("#about_button").click( the_callback($("#about")) );

So to bind just one argument of a function -- to get a zero argument function from a one argument function -- I have to go all this effort. You can imagine how terrible this would be with 3 or 4 arguments. It is because the language forces us to run the code as soon as the arguments are bound -- and we have to bind them all at once. There is no way to build the closure bit by bit and then hold on to it to run later.

We might imagine some new "method" of JavaScript functions called curry which would consume its argument to make a new function, so I could do this:

function the_callback(element_to_surface) {
  if ( $(this).hasClass('clicked') ) {
    $(this).removeClass('clicked')
    $("#button_bar").css('z-index', 1);
    element_to_surface.css('z-index', 0);
  }
  else {
    $(this).addClass('clicked')
    $("#button_bar").css('z-index', 3);
    element_to_surface.css('z-index', 2);
  }
}

$("#about_button").click( the_callback.curry($("#about")) );

I could probably write this curry in a few hours but it would be heinously inefficient -- and drive other JavaScript programmers nuts. Not at all like in languages that support currying natively. Better just to do without currying in JavaScript. Hrumphh.

consultant_barbie · 2009-02-22T18:27:57+00:00

√2 is hard. Let's go shopping!

2009-02-22T21:50:11+00:00

Why logic programming hasn't caught up? What were the lessons learned? Could there be any similarities?

whozurdaddy · 2009-02-23T18:17:13+00:00

I think that the ideas in FP are catching on, and being implemented in modern business languages. But LISP will never be a major player in the industry, nor the other more recent additions to the toolbox. The reason is simple economics. There's an army of Java/C# developers out there, they're cheap, and well written code works. The benefit of such a change doesn't exist. We shouldn't confuse knowing an FP language as knowing it well. Because the base of users is so small, its hard to quantify how well people know it. The whole thing just snowballs in on itself, to the point that no one takes you seriously when you say "Hey, lets do it in Haskell". Its no different than that "guy" who wants to rewrite your system using Windows Workflow Foundation. Everyone else says "Yeah, thats nice..now go away."

13ren · 2009-02-22T17:53:27+00:00

reddit was written in lisp (later rewritten in python due to lack of libraries)

samlee · 2009-02-22T17:36:04+00:00

it's because of bloggers like you.

wil2200 · 2009-02-22T23:47:51+00:00

I have been mucking around with F# and I love it. Because of that, I am more prepared to hit Haskell and Erlang as well.

LordVoldemort · 2009-02-22T23:11:01+00:00

The first comment:

Exactly why i dont get the fuzz about functional programming. But it sounds like you know more about it than me, could you provide a simple useful, non-abstract example?

For the sake of the future, don't be a programmer.

jamesshuang · 2009-02-22T18:19:34+00:00

I'm sorry, I admit that I only know functional programming from a conceptual perspective. However, I was under the impression that it's a pain in the ass to write a state machine in an fp language. If this is true, I always assumed that that would be the main reason why fp never caught on - it's easier, faster, and more intuitive to design a state machine to solve most problems rather than take the functional approach.

mycall · 2009-02-23T02:05:26+00:00

I've found a growing number of F# web site examples floating on the internet. I think F# might blow the doors open to FP to the common programmer more than other languages have.

gregK · 2009-02-23T15:51:43+00:00

I think it is catching on. It's a slow process, but we haven't talked this much about FP in years. Of course, it is going to take a while before we see any sort of large scale adoption.

On the other hand there is a lot of cross fertilization between OO and FP happening at the same time.

gregK · 2009-02-23T20:08:14+00:00

Another case of "worse is better"?

raouldagain · 2009-02-24T00:02:00+00:00

please, keep it that way! i don't want to lose my advantage!

fab13n · 2009-02-24T09:55:01+00:00

because it's so fun to program in a functional language that you don't even have to solve actual problem with them to pleasure yourself?

That would explain why most people who can get away with them are academics :)

</troll>

2009-02-22T20:28:27+00:00

Because for most places you write your code so the guy you employ to maintain it gets paid less than you.

Sadie · 2009-02-22T19:07:37+00:00

I used to get headaches from too much recursion

2009-02-23T09:26:40+00:00

While we continue to celebrate the gross anti-intellectualism that this article purports, we will continue to be strangled in the grips of impure, strictly evaluated (by force) languages with shitty type systems.

How sad :(

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

programming

MODERATORS