lambdaway :: abstraction

4 | list | login |load

| |

{style 
 body { background: #444; color: #fff; }
 #page_content { 
    background: #444; color: #fff; 
    font: normal 1.20em papyrus,times; }
 .page_menu { background: #444; color: #fff; }
}

{uncover https://i1.wp.com/moifemmes.com/wp-content/uploads/2017/04/IMG_1076.jpg 100 600 Famous Georgian pianist Khatia Buniatishvili} 
;; {uncover https://assets.afcdn.com/story/20190929/2024685_w980h638c1cx2933cy2091cxt0cyt0cxb5760cyb3840.jpg 100 500 Mais fous-moi la paix, laisse-moi jouer au lambda-calcul...}

_h1 abstractions & piano

_p Un langage de programmation sert à produire du {b code} destiné à être évalué/réduit/exécuté par une machine remplie de silicium ou éventuellement par une pianiste pleine de grâce.

_h2 évaluation

_p Un code lambdatalk est constitué de mots et d'expressions. L'évaluateur de lambdatalk saute les mots, repère les expressions et les évalue en temps réel. En voici un exemple :

{pre
'{sqrt {+ {* 3 3} {* 4 4}}}
;; -> {sqrt {+ {* 3 3} {* 4 4}}}
}

_p N'ayez pas peur, il ne s'agit que d'une forme abrégée, genre sténographie, de cette longue phrase : "{i S'il te plait, calcule la racine carrée (square root in english) de la somme du produit de 3 par 3 et du produit de 4 par 4}". Je suis sûr que vous pouvez faire le calcul par vous-même. Il y a trois niveaux d'emboîtements :

_ul 1) vous repérez les deux expressions internes {b '{* 3 3}} et {b '{* 4 4}} et vous les remplacez par leurs valeurs, 9 et 16 ; l'expression initiale se réduit à {b '{sqrt {+ 9 16}}}
_ul 2) vous repérez l'expression interne {b '{+ 9 16}} et vous la remplacez par sa valeur, 25 ; l'expression initiale se réduit à {b '{sqrt 25}}
_ul 3) vous calculez la racine carrée de {b 25} -- {i oui le nombre dont le carré est 25} -- et vous obtenez la valeur {b 5}. Et c'est fini.

_p Rien de magique donc. C'est ainsi que procède mon petit langage [[lambdatalk|http://lambdaway.free.fr/lambdawalks/]].

_h2 abstraction

_p Mais parfois l'évaluation échoue, par exemple si vous écrivez

{pre
'{sqrt {+ {* a a} {* b b}}}
;; -> {sqrt {+ {* a a} {* b b}}}   // Not a Number
}
_p les mots {b a} et {b b} n'ont pas de valeurs numériques, les opérateurs arithmétiques - addition, multiplication, ... - ne sont pas contents du tout et la réponse est sans appel : {b NaN}, Not a Number. Pour s'en sortir il suffit de mettre {b en attente} cette expression inévaluable en l'état, on la cache (abstraction) dans une boite appelée {b fonction}, avec un nom facile à retenir enregistré dans un dictionnaire
{pre
'{def hypoténuse                        // le nom donné à
 {lambda {a b}                         // une fonction de deux arguments
         {sqrt {+ {* a a} {* b b}}}    // dont le corps est une expression 
                                       // inévaluable en l'état
}}
-> {def hypoténuse {lambda {a b} {sqrt {+ {* a a} {* b b}}}}}                          // ce nom est conservé 
                                       // dans un dictionnaire
}
_p Quand on connait les valeurs de {b a} et {b b} on les fournit à la fonction, qui remplace les {b a} et {b b} par {b 3} et {b 4}, l'expression devient alors évaluable, elle est évaluée et la fonction peut retourner sa valeur. Ainsi
{pre
'{hypoténuse 3 4}
-> {hypoténuse 3 4}

'{hypoténuse 1 1}
-> {hypoténuse 1 1}

}
_p C'est ainsi qu'on enrichit le dictionnaire en séparant la définition d'une fonction de son application. Coder n'est rien d'autre que de créer des suites de fonctions et de les combiner ensuite entre elles et quelques mots choisis.

_p Mais vous n'aimez peut-être pas les maths, le théorème de Pythagore ne vous inspire rien. Voici un exemple pour les littéraires :

{pre
'{def hello {lambda {:a :b} My name is :b, :a :b.}}
-> {def hello {lambda {:a :b} My name is :b, :a :b.}}

'{hello James Bond}
-> {hello James Bond}

'{hello Monica Bellucci}
-> {hello Monica Bellucci}
}

_p Je suis sûr que vous avez compris ce que fait cette fonction, elle remplace tout simplement les mots {b :a} et {b :b} dans la phrase qui constitue le corps de la fonction par les noms donnés. Rien de magique.

_p Dans le {b λ-calcul} des années 30 Alonzo Church parlait d'Abstraction et d'Application, Alinea parlerait de principes Féminin et Masculin, Mélusine y verrait le Yin et le Yang, l'ombre du TAO. Certains pourraient même suggérer la Gauche qui protège et la Droite qui exploite. Chacun y voit ce qu'il veut, c'est une auberge espagnole, et vous qu'y voyez-vous ?

_h3 application

_p Au passage on a découvert deux outils, deux "formes spéciales", {b def & lambda}, avec lesquelles on démontre qu'on peut écrire tous les algorithmes possibles et imaginables. Tous les langages informatiques procèdent de cette même fondation. On peut même faire plus simple. Il est intéressant sur le plan théorique -- {i disons pour le fun} -- de comprendre que la forme spéciale {b def} est optionnelle, que l'essentiel se trouve dans la forme spéciale {b lambda}. En effet on peut écrire ce genre d'expression bizarre :

{pre
'{{lambda {a b} {sqrt {+ {* a a} {* b b}}}} 3 4}
-> {{lambda {a b} {sqrt {+ {* a a} {* b b}}}} 3 4}
}

_p qui aboutit au même résultat que la fonction hypothénuse. On a créé au vol une {i fonction anonyme, sans nom}, {b '{lambda {a b} {sqrt {+ {* a a} {* b b}}}}} et on l'a appliquée immédiatement à deux valeurs, {b 3 & 4}. C'est une opération "one shot", la fonction disparaît une fois appliquée. Dans leur délicieux sabir les codeurs appellent {b IIFE} cette expression, {b I}mmediately {b I}nvoked {b F}unction {b E}xpression, ce qui revient au même.

_p Quel peut être l'intérêt de n'avoir qu'une seule forme spéciale, la {b lambda}, une fonction anonyme, une {b abstraction} ? Analysons brièvement le Jeu des {b [[Tours de Hanoï|?view=hanoi]]}.

_img https://upload.wikimedia.org/wikipedia/commons/thumb/e/e8/AnimeHanoiNB.gif/440px-AnimeHanoiNB.gif

_p Le but ici est de déplacer 4 disques de A à B, un par un et jamais un disque plus grand sur un plus petit. En une {b cascade d'applications de lambdas} le code suivant

{pre
'{{lambda {:n :from :to :via}
{{{lambda {:g} {:g :g}} 
   {lambda {:g :n :from :to :via}
  {{{lambda {:a :b :c} {:a :b :c}}
    {{lambda {:c} {:c 
      {lambda {:a :b} 
       {lambda {:a :b} :b}}}} :n}
        {lambda {:g :n :from :to :via} }
         {lambda {:g :n :from :to :via} {:g :g 
         {{lambda {:c} {:c 
           {lambda {:a :b} :b}}} :n} :from :via :to} {br} move 
           {{lambda {:c} {:c 
             {lambda {:a :b} :a}}} :n} from tower :from to tower :to {:g :g
             {{lambda {:c} {:c 
               {lambda {:a :b} :b}}} :n} :via :to :from} }}
                 :g :n :from :to :via}}} :n :from :to :via}}
               {{lambda {:a :b :c} {:c :a :b}} Disk_1
               {{lambda {:a :b :c} {:c :a :b}} Disk_2
               {{lambda {:a :b :c} {:c :a :b}} Disk_3
               {{lambda {:a :b :c} {:c :a :b}} Disk_4 
                 {lambda {:a}
                  {lambda {:a :b} :a}}}}}} A B C}
-> {{lambda {:n :from :to :via}
{{{lambda {:g} {:g :g}} 
   {lambda {:g :n :from :to :via}
  {{{lambda {:a :b :c} {:a :b :c}}
    {{lambda {:c} {:c 
      {lambda {:a :b} 
       {lambda {:a :b} :b}}}} :n}
        {lambda {:g :n :from :to :via} }
         {lambda {:g :n :from :to :via} {:g :g 
         {{lambda {:c} {:c 
           {lambda {:a :b} :b}}} :n} :from :via :to} <br> move 
           {{lambda {:c} {:c 
             {lambda {:a :b} :a}}} :n} 
                         from tower :from to tower :to {:g :g
             {{lambda {:c} {:c 
               {lambda {:a :b} :b}}} :n} :via :to :from} }}
                 :g :n :from :to :via}}} :n :from :to :via}}
               {{lambda {:a :b :c} {:c :a :b}} Disk_1
               {{lambda {:a :b :c} {:c :a :b}} Disk_2
               {{lambda {:a :b :c} {:c :a :b}} Disk_3
               {{lambda {:a :b :c} {:c :a :b}} Disk_4  
                 {lambda {:a}
                  {lambda {:a :b} :a}}}}}} A B C}
}

_p liste les 15 mouvements. Une cascade de lambdas qui n'est qu'une infime partie des algorithmes composant un programme de longueur courante. Une cascade de lambdas qui pourrait être comparée en complexité à la cascade de notes illustrant la {b Danse Macabre} de Camille Saint Saëns et jouée par une remarquable pianiste :

{iframe {@ width="580" height="315" src="https://www.youtube.com/embed/VbmT-I35k10" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen}}

;; _p Je ne peux pas m'empêcher de voir une similitude entre cette {b cascade de notes} illustrant La danse Macabre de Saint-Saëns - et cette {b cascade de lambdas}.

_p Combien de temps a-t'il fallu à cette pianiste pour mémoriser ces milliers de notes et les confier "aveuglément" à ses vingt doigts courant sur le clavier à la vitesse de l'éclair ? Lui laissant le choix ultime de les activer à son rythme, retards, attentes et accélérations, et d'apporter la touche d'incertitude et d'émotion qui font l'oeuvre d'art.

_p Bien heureusement, cette pianiste n'a pas eu à mémoriser des milliers de notes. Elle a mémorisé une poignée d'arrangements mélodiques et de motifs harmoniques -- en fait les {b abstractions} -- et elle a laissé à son cerveau la responsabilité d'en faire {b l'application} à l'ensemble réduit des 7+5 = 12 notes réparties sur les 6 octaves d'un piano. A la façon dont on déplace les disques des tours de Hanoï. Suivant la même logique automatique.

_p En prime, voici la version pour orchestre, dont je ne me lasse pas :
 {iframe {@ width="580" height="315" src="https://www.youtube.com/embed/71fZhMXlGT4" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen}}

_p Entre Camille Saint-Saëns qui a pu concevoir dans sa tête cet océan de sons, l'écrire sur une partition en suivant les règles strictes du solfège, et l'orchestre capable de nous le faire entendre, l'élégant violoniste solo, la belle hauboïste, la jolie flutiste, tous ces gens différents unis dans le même bâteau sonore, je ne sais ce qui est le plus beau. Moment de grâce.

_h2 extrapolation

_p Et ça fait rêver à la possibilité de faire fonctionner le lambda-calcul dans notre cerveau à la même vitesse. Il a fallu du temps et du travail à cette pianiste pour pouvoir jouer ce morceau, il en faudrait au moins autant pour que notre cerveau puisse interpréter aussi vite un code lambda-calcul. Il y aura peut-être un jour une école de lambda-calcul comme il y a des écoles de musique pour former des humains capables de manipuler les algorithmes à cette vitesse, aidés ou non par des machines, des pianos à algorithmes. Je suis sûr qu'il en existe déjà.

_p Alors avec un peu (beaucoup) d'entrainement on pourra un jour jouer avec de beaux algorithmes comme cette pianiste joue du piano. Par exemple pour générer des palettes de parfums, de couleurs, des sons, des voix, des formes, de belles créatures ...

_p alain marty (2022/09/29 - 2024/08/28)

{uncover https://georgianjournal.ge/media/images/georgianews/2017/July/Society/khatia-buniatishvili%202.jpg 100 400 Famous Georgian pianist Khatia Buniatishvili}