C'est comme si l'apprentissage des mathématiques améliorait vos compétences analytiques et que l'apprentissage de la littérature latine / classique améliorait vos compétences en écriture.
Les personnes qui ont conçu ces langues ont réfléchi à ce que signifie écrire un programme. Et ces langues sont les résultats de ces recherches.
Cela dit, l'apprentissage de Java fera également de vous un meilleur programmeur. Et apprendre C. Les avantages réels proviennent de l’apprentissage de langues avec une philosophie différente. Vous pourrez alors avoir votre propre opinion sur la manière dont un programme devrait être écrit.
modifier
Je me rends compte que cette réponse n’est pas très utile pour les personnes qui n’ont pas encore appris le haskell et / ou le lisp. Voici quelques exemples pour expliquer davantage ce que je veux dire
ZÉZAYER
Lisp pense que la syntaxe devrait être minimale et que tout devrait être une liste ou une primitive (Lisp signifie Traitement de liste). Même les programmes sont principalement des listes contenant d’autres listes et symboles. Lisp vous permet de manipuler des programmes sous forme de liste et de générer de nouveaux programmes à la volée. D'où toute la code is data and data is code
devise.
La conséquence directe est que les langages Lisp vous permettent de définir l’interface de votre choix. Un bon exemple est compojure, qui est un framework web de clojure. Voici à quoi ressemble une fonction de routage
(defroutes app-routes
(GET "/" [] view/page)
(GET "/api" [] (wrap-aleph-handler api/socket-handler))
(route/resources "/static")
(route/not-found "page not found"))
Un autre bel exemple est le framework de création de hiccup:
(html [:ul
(for [x (range 1 4)]
[:li x])])
Comme vous pouvez le constater, le résultat est aussi succinct que dans DSL comme moustache, mais vous permet d’utiliser les fonctionnalités du langage telles que (for [x (range 1 4)] block)
. Encore plus agréable, vous avez tous les outils pour résumer et structurer votre code.
Dans d'autres langues, la syntaxe est plus complexe. Vous ne pouvez pas lire un programme Java en tant que groupe de listes. Mais en utilisant Lisp, vous avez une meilleure idée de ce à quoi devrait ressembler une interface idéale et de ce que votre code peut être extrait sous forme de données. Cela vous aide également à voir votre langue préférée comme une grande structure de données et à mieux comprendre sa sémantique.
Haskell
Haskell croit au typage statique fort et à la pureté. Les fonctions pures ressemblent aux fonctions mathématiques: elles sont définies sur un ensemble de valeurs et mappées sur un autre ensemble. Les fonctions n'ont pas d'effets secondaires et les valeurs sont immuables. La pureté est intéressante parce que ce n'est pas quelque chose qu'un langage multi-paradigme peut avoir. Une langue est pure ou non.
Une conséquence est que vous ne pouvez pas effectuer d'action IO quand vous le souhaitez (Haskellers pense que c'est une bonne chose). Les actions IO sont définies comme des transactions, qui sont elles-mêmes des valeurs pures. La main
valeur d'un programme haskell est une transaction IO exécutée lorsque vous exécutez le programme.
Vous devez traiter explicitement du flux de données dans votre programme. Vous ne pouvez pas faire communiquer deux composants en écrivant et en lisant des éléments dans une variable globale. Vous devez construire et transmettre des valeurs.
Une autre caractéristique mentionnée par Jimmy Hoffa est le système de type riche. Tandis que d'autres langues utilisent le typage statique, dans haskell vous pouvez avoir des choses comme:
length :: [a] -> Int
(fonction d'une liste de a à un int)
map :: (a -> b) -> [a] -> [b]
(fonction qui prend une a to b
transformation et une liste de a, et retourne une liste de b)
La bonne chose est que je n'ai pas besoin d'expliquer ce que ces fonctions font réellement: vous comprenez déjà leur comportement. De plus, les fonctions portant ces signatures ne peuvent en réalité que calculer la longueur d'une liste et mapper une transformation sur une liste.
Dans d'autres langages typés, les hiérarchies de classes associées à la mutabilité font de la gestion de ces types un cauchemar. Vous devez comprendre des choses telles que la covariance et la contravariance, impossibles à comprendre du point de vue linguistique (c.-à-d. Simple, puissant et sûr).
Soit vous prenez le chemin sûr (comme scala) et vous vous retrouvez avec un langage très complexe, soit vous prenez le chemin simple et obtenez quelque chose qui est soit limité (google go génériques limités à la liste et aux cartes) ou peu sûr covariant).
En utilisant haskell, vous découvrez principalement les avantages de la pureté et comment écrire du code pur.