[Haskell] Haskell in industry?

[Graham Klyne]

I regard myself as a practical "in the trenches" kind of programmer, not an 
academic researcher, (though I seem to work in the murky no-man's-land 
between research and commercial exploitation, and have tended to operate at 
the "bleeding edge" for my commercial work).  I see real value in Haskell 
as a language for commercial use, *provided* it gets strong library support 
for a range of support functions.

FWIW, I have used Haskell to implement tools for helping me perform some 
real work ([1] is a document prepared from Semantic Web data using, in 
part, a translator program [2] written in Haskell), but as yet have not 
delivered any commercial code written in Haskell.

[1] http://www.ietf.org/internet-drafts/draft-klyne-hdrreg-mail-05.txt
[2] http://www.ninebynine.org/Software/CompileRDF/RepToRDFMain.hs (and 
related files)

At 20:18 14/09/04 +0200, Heribert.Schuetz.extern at HVB.de wrote:
>*       Will Haskell programmers be available 5 years from now to do the
>rather boring work of maintaining a then-legacy system? (Well, here I don't
>expect definitive answers. I just mentioned it here to give you a more
>complete picture. Unfortunately there was not much response to Jochen
>Leidner's message from September 2. BTW, with "then-legacy system" )

I think that several universities are teaching Haskell now (I note that 
Oxford teaches Haskell as the *first* language introduced in its CS 
course).  This bodes well for future availability of programmers who have 
at least heard of Haskell.

I've been talking to people about using Haskell in conjunction with the Web 
(especially Semantic Web), where I think there is a good fit (if/when the 
required support libraries are available).  The kind of response I'm 
getting is not so much "Haskell what?" (as it is in some other fields), but 
"I've heard of that, it looks cool, I must investigate further".

>*       Can't much of the simplicity of the Haskell code also be reached by
>just switching from C++ to something like Java or C#? (Probably an example
>from the application domain will be most convincing. So I probably have to
>bite the bullet and reimplement some code in Java or C#. But if you have
>some examples, they might be helpful. The quicksort example in
>http://www.haskell.org/complex/why_does_haskell_matter.html is unfortunately
>Haskell vs. C++.)

For small programs, I think Haskell simplicity is difficult to transfer 
into other languages.  The use of higher order functions seems to open up a 
number of very neat ways of expressing algorithmic ideas.  For larger 
programs, I'm less certain, in that it seems to me that the overhead of 
organizing larger bodies of code may be largely independent of the 
language.  That said, Haskell seems to support a wider range of programming 
styles and idioms within what is at core a very simple language 
design.  (An example I think of is the work on aspect-oriented programming 
in conventional OO languages, one of whose goals is separation of 
cross-cutting concerns.  It seems to me that this potential comes for free 
in a language with higher order functions.)

In a world where software reliability concerns are becoming more widespread 
and urgent, I think think Haskell has some real advantages that other 
languages really would be hard-pushed to match.  So, for commercial use, I 
guess I'd be more inclined to emphasize that aspect than simplicty.  (The 
fly-in-the-ointment here is predicting resource usage, which can impact 
reliability.  Much as I like Haskell, maybe ML would be a better choice?)

Further, I think that Haskell has great strengths from a software 
engineering standpoint, in that higher order functions provide a powerful 
set of tools for isolating different parts of an application.  I've 
generally been very impressed by how easy it is to use a variety of 
different function libraries working together in a single application -- 
there seems to be little need to overcome stylistic programing idioms to 
make different libraries work together cleanly (this is less true of 
libraries that are heavily monad-based, IMO).  (Cf. the "Scrap your 
boilerplate" work.)

Another factor, central to your concerns, is maintainability.  Usually, I 
really hate trying to figure out other people's code.  With Haskell, I have 
found the process to be quite painless.  Once the relevant higher-level 
concepts have been identified, working with and modifying existing code 
seems to be quite easy.  (Again, in my experience, less so where monads are 
heavily used.)

And finally, tangentially, there's an article someone told me about 
recently that is probably quite well known to old hands in this community, 
but which was new to me...

"Haskell vs. Ada vs. C++ vs. Awk vs. ..., An Experiment in Software 
Prototyping Productivity"
   http://www.haskell.org/papers/NSWC/jfp.ps

#g


------------
Graham Klyne
For email:
http://www.ninebynine.org/#Contact