Article : "37 reasons to love Haskell"

J'ai décidé d'apprendre Haskell, après OCaml il y a 18 mois.

Au passage, j'ai trouvé cet article intéressant :

37-reasons-to-love-haskell-playing-off-the-ruby-article/

Haskell me semble plus utilisable dans la pratique que OCaml, qui est quand même assez bor.del.lique. Bien sûr, il faut être prêt à sacrifier l'impératif et l'OO ...

Remarque que l'article date un peu, par exemple ghc en est à 3.10.1 maintenant, il y a bien un débuggueur intégré, plutôt puissant bien qu'assez surprenant à utiliser au départ (débugguer un langage à évaluation paresseuse n'est pas toujours évident) et les recherches sur Data parallel Haskell et les stratégies parallèles sont bien plus avancées. De plus le nombre de librairies matures, le support d'Unicode etc... ont progressé également durant tout ce temps.

En général je dirais que la plupart des arguments développés dans ce post sont d'autant plus valables aujourd'hui.

OCaml est relativement pratique, Haskell a une approche plus pure du fonctionnel, ce qui produit des solutions différentes de celles adoptées en OCaml, les deux langages sont intéressant. Ma préférence personnelle va à Haskell toutefois, je le perçois comme un langage plus prometteur à terme.

Oui l'article date un peu, depuis il y a encore plus de bonnes raisons d'utiliser Ruby

Je suis du même avis que Jedai, le multi-paradigme est plus une facilité qu'une complication.
À mon avis Haskell est encore plus coûteux en apprentissage que OCaml qui est pourtant déjà assez exigeant. Parce que le temps que tu vas gagner à ne pas jouer à Dr. Expression et Mr. Instruction tu risque de le reperdre en jouant à Dr. Lazy et Mr. Strict qui sont les mêmes personnages qui se cachent derrière un masque de pure fonctionnalité.

A propos d'avantages du fonctionnel, je suis récemment tombé sur ce petit texte qui expose très clairement l'un des mécanismes qui joue en faveur du fonctionnel statiquement typé. Ceci est valable autant pour Haskell que pour du OCaml fonctionnel.

> Je suis du même avis que Jedai, le multi-paradigme est plus une facilité qu'une complication.

Je n'ai pas dit ça. J'ai dit que c'était un choix de compromis, alors qu'Haskell est un effort pour montrer que le fonctionnel pur n'est pas un simple rêve de théoricien.

Personnellement ces compromis d'OCaml sont une bonne part des raisons pour lesquelles je préfère Haskell. A la surprise de beaucoup, Haskell est maintenant un langage réellement utilisable pour des taches pratiques et même particulièrement bien adapté à certains domaines, sa pureté a forcé le développement ou l'implémentation de nouveaux concepts intéressants et il en récolte maintenant les fruits.

OCaml permet d'écrire du bon code mais il est extrêmement facile de déraper et de perdre certaines des bonnes propriétés du fonctionnel en retombant dans des méthodes impératives par facilité.

D'un autre côté, avec un minimum d'expérience, on peut séparer le pur de l'impur en OCaml, comme en Haskell avec les monades (avouons que c'est l'utilisation majeure des monades).

Les deux ont leurs avantages et leurs inconvénients... Et j'aime bien les deux

@Jedai> perso, je trouve ton lien très peu convaincant... car beaucoup à apprendre le lecteur soit pour un démeuré, soit pour un converti.

et ce serait pas mal d'éviter de dire "typage statique fort => programmation fonctionnelle" même si C ne plaide en faveur de l'impératif, on peut voir pascal et ada

> et ce serait pas mal d'éviter de dire "typage statique fort => programmation fonctionnelle"

Ce n'est pas ce que dit le lien que j'ai cité. L'argument tel que je le comprend est qu'un typage statique fort dans un langage fonctionnel a plus d'opportunité de repérer des erreurs que dans un langage impératif parce qu'en impératif l'ordonnancement des opérations est un élément que le typage ne peut pas vraiment contrôler, en fonctionnel cet "ordonnancement" est explicite et sous contrôle du système de type.

Il y a bien sûr toujours des occasions où le typage manquera certains bugs, en particulier quelque soit le cas le typage ne peut pas aider si l'algorithme lui-même est incorrect, mais dans les cas 1 et 2 décrits dans l'article (c'est-à-dire erreurs bêtes sans rapport avec l'algo et erreur dans l'implémentation d'un algo correct) les bugs sont plus susceptibles d'être repérés à la compilation dans un langage fonctionnel avec typage statique fort que dans un langage impératif.

Je trouve l'argument relativement convaincant même si l'exemple donné ne l'est pas vraiment et suis surpris que tu penses que seul un demeuré ou un converti puisse l'accepter. Et il est notable qu'un grand nombre de débutants sont surpris par le fait qu'une fois qu'ils arrivent à compiler un programme en OCaml/Haskell ils est bien plus souvent correct que dans la plupart des autres langages qu'ils ont essayé auparavant.

C'est du moins mon expérience, bien sûr c'est encore plus notable pour les programmeurs qui n'ont eu d'expérience qu'avec des langages comme C auparavant.