[Haskell-cafe] Re: New slogan... (A long speculation)

[jerzy.karczmarczuk at info.unicaen.fr]

Thomas Conway writes: 

> I was observing that Melbourne Uni (my old school), is switching in
> the new year from teaching Haskell as a first language, to teaching
> Python. I was dismayed, but not surprised.
... 

This was commented already, but perhaps a few words from a different
perspective. Computer scientists (even an illegitimate one, like myself)
love teaching functional languages...
I think I was one of first people in my dept., University of Caen, Normandy,
France, who taught Scheme on a regular basis, to math students. The merits
of Scheme contributed to our decision to teach it as the first language to
Science students (in France they don't begin as "Comp. Sci. students", but
more generally, and specialize afterwards [[e.g., choosing physics because
they hate programming, or math, because they had lousy results in physics...
etc.]] 

We did it for 15 years, or more, but then some people from electronics, from
physics, etc., our colleagues with whom we are de facto pedagogically
married, began to complain. There were many silly arguments against Scheme,
we could have dismissed all that. But there were arguments which were
(for me) quite reasonable and relevant. One of them was quite superficial,
but interesting, and I will come to it in a while: 

* Scheme is very different from what we practice (C++, Fortran, etc., you
 know the song...) It may slow down the *adaptation* of students. They
 *will need* all that imperative stuff you hate. But, as a first language,
 the FLs condition the young minds in a way we do not appreciate.
 -- 

I was personally convinced that the passage to some imperative language was
after all not so bad because of another argument. The first language taught
has a particular, not always wanted flavour: it is perceived as an academic
language, conceived for being *taught*, and not really used. Students know
that they must do some assignments, pass exams, etc. They feel coerced, and
not necessarily see this training as a trampoline for their future fabulous
software. 

So, after some negotiations, we chose Python (nobody felt that we should
be worry that Python won't be used...), and I was one of the protagonists of
this solution. But, simultaneously, I advertized very modestly Haskell, and
now our students begin with Python, at their 2nd year they have also Java
but also a bit of Haskell, and the 3rd year, their Licence diploma, they
must learn Haskell not just as a programming language, but as something
which permits to solve problems in AI, in compilation, in language
processing, in some computational logic, etc. It turns out that having the
possibility to *compare*, students assimilate Haskell with more conviction.
They appreciate the compactness, *because* they have seen Java at work. Etc. 

== 

So, there is no need to be dismayed.
And one more thing. I wonder whether the slogans which underline the merits
of the *language* Haskell is the best possible approach. Perhaps it would be
interesting to try to sell the elements of the paradigmatics of modern FP: 

 - automatic type inference in a powerful polymorphic setting
 - laziness (eventually)
 - purity which is good for proving things, etc.
 - monads as universal structuring tools ... 

 -- in a way not necessarily fusioned with a language. But this means that
we should have *more* functional languages to enable some comparisons.
There is no lazy untyped language. Why?? (No, don't tell me that we have
the delay macro in Scheme. I cannot code my co-recursive algorithms without
a lazy letrec, or a painful gymnastics.) Worse, some people from time to
time complain that Clean exists, and they suggest that effort put into it
could be used to improve Haskell. Such people serve the Devil! 

So, perhaps this is a perverse philosophy, but I see some sense in making
several languages, exploiting some facettes of FP separately, as a way of
throwing the bridge between our Glorious Kingdom and Le Monde des 
Ténèbres.
Yes, finding some *comparable* competitors would do much good. Some niches
are already occupied and busy, e.g., the domain where Erlang is strong. But
there is yet some mileage to go. 

Jerzy Karczmarczuk