🛠️ 🤛🏼 🏸 La programmation fonctionnelle devrait être votre priorité n ° 1 en 2015 🙅🏿 🤳🏾 👉🏽

"L'OLP ne pourra plus nous sauver des Cloud Monsters."

Note du traducteur: Il y a deux concepts - le parallélisme (exécution simultanée, indépendante) et la compétitivité (exécution pas à pas, à son tour, mais en même temps plusieurs tâches) et, comme toujours, j'ai dû me casser la tête en choisissant les bons termes.

Je vais dupliquer certains mots ou termes entre parenthèses dans l'original, afin de rechercher des informations supplémentaires en termes anglais, qui seront plusieurs fois plus.

Peut-être avez-vous déjà entendu une telle expression, comme: «Clojure», «Scala», «Erlang» ou même «Java a maintenant des lambdas». Et vous avez, quoique une idée lointaine de la «programmation fonctionnelle». Si vous êtes membre de tout type de communauté de programmation, ce sujet pourrait déjà être discuté par vous.

Si vous recherchez dans Google la phrase "Programmation fonctionnelle", vous ne verrez rien de nouveau. La deuxième langue de celles créées précédemment couvre déjà ce sujet; elle a été créée dans les années 50 et s'appelle Lisp. Alors, bon sang, ce sujet est devenu populaire tout à l'heure? À peine 60 ans plus tard?

Au début, les ordinateurs étaient très lents

Croyez-le ou non, les ordinateurs étaient les plus lents que les DOM. Pas vraiment. Et en même temps, il y avait 2 idées principales dans l'accord sur la conception et la mise en œuvre des langages de programmation:

Commencez avec l' architecture von Neumann et ajoutez l'abstraction.
Commencez par les mathématiques et supprimez l'abstraction.

Les ordinateurs n'avaient pas assez de puissance de calcul pour gérer toutes les abstractions et faire face aux programmes écrits dans un style fonctionnel. Lisp était donc épuisé auparavant, étant extrêmement lent et donc impropre au travail. C'est alors que la domination du style de programmation impératif a commencé, surtout avec l'apogée de C.

Mais les ordinateurs se sont beaucoup améliorés.

Maintenant, il est devenu presque normal d'utiliser la plupart des applications, sans se soucier complètement de la langue dans laquelle elles ont été écrites. Les langages fonctionnels ont enfin eu une seconde chance.

Programmation fonctionnelle 50,5

Cet article n'est en aucun cas une introduction à FI. À la fin de cette section, vous aurez besoin de savoir ce qu'est la FA et comment commencer votre voyage d'étude.

Vous pouvez comprendre le terme «programmation fonctionnelle» trop littéralement comme une programmation utilisant des fonctions et ce n'est pas loin de la vérité. Vous allez créer des fonctions en termes d'autres fonctions et écrire des fonctions (vous souvenez-vous du f ∘ g du programme scolaire? Maintenant, il sera utile). C'est tout.

La liste (non complète) des fonctionnalités de FP:

Fonctions de première classe
Fonctions de haut niveau
Fonctions pures
Fermetures
État immuable

Maintenant, vous n'avez pas à vous soucier de ces termes étranges, comprenez simplement ce qu'ils signifient.

Les fonctions de la première classe permettent d'enregistrer des fonctions dans des variables. Je suis sûr que vous avez fait quelque chose de similaire, comme dans l'exemple JavaScript:

var add = function(a, b){
  return a + b
}

Vous venez de créer une fonction anonyme qui obtient a et b et renvoie a + b , et affecte cette fonction à la variable add .

Les fonctions d'ordre supérieur signifient que les fonctions peuvent renvoyer des fonctions ou accepter des fonctions comme paramètres.

Et encore en JavaScript:

document.querySelector('#button')
  .addEventListener('click', function(){
    alert('yay, i got clicked')
  })

var add = function(a){
  return function(b){
    return a + b
  }
}
 
var add2 = add(2)
add2(3) // => 5

Les deux options sont un exemple de fonctions d'ordre supérieur, même si vous n'avez pas écrit quelque chose comme ça, vous avez peut-être vu quelque chose de similaire ailleurs.

Les fonctions pures signifient que la fonction ne modifie pas les variables, elle accepte simplement les données et renvoie les données, comme nos fonctions préférées des mathématiques. Cela signifie également que si vous appelez la fonction f avec l'argument 2 et qu'elle renvoie 10 , elle renverra toujours 10 . Peu importe l'environnement, le nombre de threads ou l'ordre d'exécution. Ils ne provoquent aucun effet secondaire dans d'autres parties du programme et c'est un concept vraiment puissant.

Des courts-circuits signifie que vous pouvez enregistrer des données à l'intérieur de la fonction qui seront disponibles dans une fonction de retour spécifique, en d'autres termes, la fonction de retour stocke son runtime.

var add = function(a){
  return function(b){
    return a + b
  }
}
 
var add2 = add(2)
add2(3) // => 5

Regardez à nouveau le deuxième exemple du paragraphe Fonctions d'un ordre supérieur , la variable a a été fermée et n'est disponible que dans la fonction retournée. En fait, les fermetures ne sont pas une caractéristique du paradigme FP, mais plutôt une optimisation.

Un état immuable signifie que vous ne pouvez changer aucun état (bien que vous puissiez en créer de nouveaux). Dans le code suivant (sur OCaml), vous définissez la variable x sur 5 et x sera toujours 5 .

let x = 5;;
x = 6;;

print_int x;;  (* prints 5 *)

Ces fonctionnalités semblent assez étranges, mais vous verrez bientôt comment elles vous facilitent la vie.

La programmation orientée objet ne peut plus vous protéger

C'est une période prometteuse où nous pouvons enfin avoir des applications distribuées et multithreads. Malheureusement, notre modèle existant (ou le plus utilisé) n'est pas prêt pour le multithreading (concurrence) et le parallélisme, même s'il résout les problèmes actuels, mais il ajoute également de gros problèmes.

Pour améliorer les applications, nous avons besoin d'un moyen simple et fiable pour réaliser ce que nous voulons. Vous souvenez-vous des caractéristiques mentionnées ci-dessus de la mise au point automatique? Fonctions pures et état immuable? C'est vrai, vous pouvez exécuter des fonctions des milliers de fois sur différents cœurs ou machines et le résultat sera toujours le même. Et donc, nous pouvons exécuter le même code sur le même noyau et sur des milliers. La vie redevient sans nuage.

"Mais pourquoi ne puis-je pas continuer à utiliser la POO?"

Au moins pour le multithreading et le parallélisme, la POO ne peut plus vous aider. Parce que la POO fait référence à un état avec un état mutable (dans les langages impératifs qui sont écrits dans le style POO, dans la plupart des cas). Les méthodes appelées de l'objet sont censées changer le soi courant ou ceci . Vous devrez faire suffisamment d'efforts pour mettre à jour et synchroniser correctement tous les threads.

Je vous écris ceci pour ne pas vous inciter à passer à la FP à partir des paradigmes que vous utilisez actuellement (bien que certaines personnes diront que je devrais), mais vous devez certainement comprendre: Java et C ++ 11 ont déjà le calcul lambda. Je peux dire que presque toutes les langues modernes et prises en charge vont implémenter des fonctionnalités FP ou l'ont déjà fait.

Il convient de noter que nous ne devons pas cesser d'utiliser l'état mutable. Nous devons utiliser des entrées / sorties (IO), etc., pour que nos programmes soient utiles. L'idée principale de FP est: n'utiliser un état mutable que lorsqu'il est vraiment nécessaire.

"Je ne travaille pas avec les nuages, ai-je vraiment besoin d'étudier la FA?"

Oui.

La programmation fonctionnelle vous aidera à mieux écrire les programmes et à parler des problèmes que vous devez résoudre.

"J'ai essayé. C'est trop compliqué et difficile à lire du code. "

Le démarrage est toujours difficile dans tous les domaines. Je suis sûr que vous avez commencé à apprendre la programmation et que vous rencontrez également de nombreux problèmes, même dans les langages POO. Peut-être que commencer à écrire dans le style OOP était plus facile que d'écrire votre premier programme parce que vous connaissiez déjà certains idiomes courants, comme la déclaration de variables et les boucles for / while.

Commencer à apprendre la FP équivaut presque à recommencer à écrire des programmes à partir de zéro (quelle que soit la langue que vous avez commencé à apprendre, il sera sans ambiguïté comment commencer depuis le tout début).

Beaucoup peuvent noter que la FA est difficile à lire. Si vous avez de l'expérience dans les langages impératifs, les programmes fonctionnels ressembleront à de la cryptographie. Et non pas parce que c'est vraiment le cas, mais parce que vous ne connaissez pas ses principaux idiomes. Une fois que, ayant compris les principes fondamentaux, les programmes deviendront beaucoup plus lisibles.

Découvrez le programme écrit en Haskell et JavaScript (style impératif):

guess :: Int -> [Char]
guess 7 = "Much 7 very wow."
guess x = "Ooops, try again."

-- strongly inspired by http://learnyouahaskell.com

function guess(x){
  if(x == 7){
    return "Much 7 very wow."
  }
  else {
    return "Oops, try again."
  }
}

Ceci est un programme très simple. Il affiche un message de félicitations lorsque l'utilisateur a deviné et entré le numéro 7 ou affiche un message d'erreur dans tous les autres cas. Cela ressemble peut-être à du chiffrement, car Haskell peut faire tout le travail en seulement deux lignes de code (vous pouvez ignorer la première ligne, c'est juste une "déclaration de type"). Mais cela deviendra assez simple, une fois, après avoir compris les possibilités de mise en correspondance de modèles (qui sont implémentées non seulement dans les langages FP, mais étaient leur caractéristique).

Ce que fait Haskell:

Si l'argument accepté pour deviner est 7, alors il retournera «Beaucoup 7 très wow». ou retournera "Oooops, essayez à nouveau." dans d'autres cas.

Et c'est la même chose que le code JavaScript, mais Haskell est mappé au "modèle" déclaré par le programmeur dans le code.

Cette approche peut ne pas sembler très utile dans ce cas, si vous pouvez utiliser if / else. Mais cela deviendra vraiment utile lorsque vous commencerez vous-même à écrire des structures de données plus complexes.

plus1 :: [Int] -> [Int]
plus1 []      = []
plus1 (x:xs)  = x + 1 : plus1 xs 

-- plus1 [0,1,2,3]
-- > [1,2,3,4]

Dans le programme ci-dessus, * plus1 * est une fonction qui prend une liste d'entiers et ajoute 1 à chaque élément de la liste. La fonction compare lorsque la liste est vide [] (renvoie une autre liste vide, car elle ne contient aucun élément) contourne la liste non vide et détermine le modèle de correspondance: x comme premier élément de la liste, xs comme liste restante. Ensuite, il calcule simplement la somme et la combine via un appel récursif.

Je suis sûr que vous passerez de nombreuses minutes (pas les plus agréables), à réécrire cet exemple dans un style impératif, à ajuster le code sur deux lignes, tout en conservant la lisibilité.

Alors, commençons

De nombreux documents sur la programmation fonctionnelle ont été publiés, mais vous ne devez pas ignorer ces liens sans ambiguïté:

Principes de programmation fonctionnelle dans Scala : le cours sera utile pour ceux qui connaissent Java et veulent essayer la programmation fonctionnelle sans sauter de la JVM. Le cours couvre les concepts de base.
Paradigmes de la programmation informatique - Fondamentaux : ce cours sera utile pour ceux qui veulent apprendre à écrire des programmes dans un langage fonctionnel. Le cours utilise la langue d'apprentissage Qz. Il y a beaucoup d'exercices dans le cours, vous pouvez utiliser un langage fonctionnel et essayer de créer votre propre structure de données. Je crois que le cours fournit des blocs de construction pour le «bâtiment» appelé «Programmation fonctionnelle», il vous aidera dans d'autres langues à l'avenir.

Malheureusement, les cours ne seront disponibles qu'à la fin de l'année. Mais vous pouvez suivre le contenu et les vidéos, ils sont disponibles sur Youtube.

D'un autre côté, si vous préférez les textes, j'en recommande certainement certains:

Les deux premiers ont des programmes similaires, vous présentent les bases de la programmation fonctionnelle et sont très adaptés aux débutants. Le troisième des liens, ce cours sur les paradigmes de programmation informatique, couvre plus que la programmation fonctionnelle. Il est important de noter que ces matériaux sont pour le niveau d'entrée.

De plus, Chris Allen a écrit un excellent article sur l'étude de la programmation fonctionnelle. C'est ce qu'on appelle l'éducation fonctionnelle.et a une liste exhaustive de matériaux pour étudier la programmation fonctionnelle en utilisant Haskell, ainsi que des discussions sur les forces et les faiblesses de cette approche. En suivant les liens recommandés par Chris, vous pouvez apprendre les principes de base et les sujets plus complexes (je suis sûr que vous avez entendu parler des monades) de la programmation fonctionnelle et peut-être comprendrez-vous comment écrire des applications en les utilisant. (Merci Chris pour les liens vers les documents.)

Bonne chance avec ta nouvelle année fonctionnelle! ☺

La programmation fonctionnelle devrait être votre priorité n ° 1 en 2015