newbie conceptual question

[David Hughes]

> I have been programming with imperative languages for 15 years. Now I
> started learning Haskell, and functional programming (and I am very
> determined to learn it well). It seems to me that I can still use functional
> programming paradigm with an imperative language. How can I benefit more
> from a functional programming language (i.e.Haskell)? In other words, is
> having built-in language constructs for functional programming the only
> reason for using a functional programming language(I can use polymorpim, and
> generic programming in imperative languages, as well).


I'm sure that the regular posters will have a ream of intelligent, informed
comment to make about this.  Just for once, though, I think there's space
for a comment by a functional-programming tyro, precisely because I'm
closer to being in your shoes than, say, Philip Wadler is.  Just don't
assume I'm right (but no doubt the experts will let us know if I'm wrong. 
Have a mallet, guys).  I've appended to this message the names of a few
publications that I particularly like.

Disclaimer: the only purely functional language that I know is Haskell (and
a negligible smidgen of ML).

Point One: functional languages are powerful.  The phrase 'built-in
language constructs for functional programming' doesn't begin to describe
it.  Most imperative programmers don't even imagine the degree of
abstraction and generality these languages afford.  Polymorphism and
generic programming are, as you say, possible in imperative languages, even
if they're not always explicitly supported by the language.  Likewise
garbage-collection and (sort-of) higher-order functions.  But I say: throw
in lazy evaluation, -real- higher-order functions, currying and referential
transparency, and find out what generality and abstraction really mean.

Point Two: functional languages are beautiful.  This brings tangible
benefits as well as aesthetic satisfaction: unless you're doing something
really dirty, your Haskell program will usually be more concise, explicit
and general than its (say) Java equivalent -- often much more so.  Hence
readability and maintainability.  Moreover, I've found learning Haskell to
be a small education in itself.  It's a truism that a language is only
worth learning if it changes the way you think about programming; and
though I still mostly program in imperative languages, a functional flavour
has crept into much of my work.  Even my Perl now tends towards recursion
and non-destructive assignment, and I think this makes me a better
Perlster.

Point Three: functional languages are robust; or, rather, they very
strongly encourage robust programming.  This (along with Haskell's
delicious typing system) is mainly because they do not permit data to be
updated: if you've referred to a datum in the past, you can guarantee that
it will not differ the next time you look at it.  (Yes, this -does- give C
programmers the heebie-jeebies.  No, programs can still do useful things.) 
Hence referential transparency: given the same arguments, a functional
function will always return the same answer.  To debug an imperative
program, as my lecturer used to say, you have to understand the entire
history of the computation; in a functional program, whatever's going on is
guaranteed to be no more complex than the particular function you're in. 
Functional programs rarely need debugging; when they do need debugging, the
difficulty of the job is of a lower order of complexity than debugging an
imperative program.  Try it and you'll see.


But, of course, every powerful force has its Dark Side.

Point Four: functional languages are difficult are learn.  The experts tend
to put this statement in incredulous quotes, but I assert that it is still
true if one is trying to learn Haskell on one's own without a grounding in
certain mathematical principles that underlie the language.  I was taught
the basics by a damn' good lecturer, but most of my functional education
has been self-propelled -- and frustrating.  I've read some very good
books, but various important concepts continue to elude me even though I've
spent a fair bit of time meddling around with Haskell.  What, for instance,
the hell are monads?  Though I've read, and pondered, and though I use the
Haskell I/O system without difficulty, I still don't really grok monads
except to believe that they'd make a lot of things easier if I did
understand them.  Presumably I'm missing some fundamental insight, probably
a simple one, but what?  I don't know.

Point Five: there's a dearth of libraries.  Functional languages lack the
embarrassing plethora of libraries that come with C++ or Java or Perl.  For
instance, there are simply are no mature, maintained Haskell libraries for
GUI development or database access (as far as I know -- I haven't checked
haskell.org in a while).  So I end up using Perl::Tk and DBI.pm instead,
because the job needs to be done today.  (By the way, I understand that
other functional languages (Clean, ML (and Erlang?)) are better equipped.)


In summary, I love Haskell.  I think it knocks the socks off any other
language I've learned.  When writing Perl, my frequent refrain is, "This'd
be so much easier in Haskell!" and when programming in Haskell the cry is,
"Yum!"  But all too often I stray out of the domain of pure algorithm and
have to cope with real-world grunginess.  Then I growl in despair of ever
getting to grips with Haskell, and all too often take refuge with one of
the mainstream imperative languages (or, in extreme cases, Jack Daniels).


Yowch, I've written a monograph.  I'd better get back to my Perl before
anyone notices me goofing off.

// David
-- 
David Hughes                    -+-        office: +41 22 767 4047
UNIX Sysadmin, SERCo SA         -+-        mobile: +41 79 201 4732
Computing Centre, CERN          -+-        David.W.Hughes@cern.ch

This message may not represent the views of my employer or of CERN.

==================================================================

I recommend the following reading-matter:

    Simon Thompson, "Haskell: the craft of functional programming",
Addison-Wesley
    Paul Hudak, "The Haskell School of Expression", Cambridge Univ. Press

... and anything linked from http://www.haskell.org/bookshelf, but
especially:

    Philip Wadler, "Why no one uses functional languages"
    Philip Wadler, "What The Hell Are Monads?"