programmation fonctionnelle

Grain : un nouveau langage pour WebAssembly

Soumis par fredericmazue le

Grain est un nouveau langage qui a été présenté lors du WebAssembly Summit 2021. La présentation (video ci-dessous) a été réalisée par Oscar Spencer, un des responsables du projet.

Grain est un langage de haut niveau, fortement typé, qui compile en WebAssembly via Binaryen. Le code Grain peut donc être exécuté sur tous les navigateurs qui supportent WebAssembly.

Grain trouve ses racines dans les langages fonctionnels et ambitionne de rendre les idées propres à ces langages plus abordables qu'elles ne le sont généralement. Les responsables du projet Grain expliquent :

Grain vise à moderniser les fonctionnalités innovantes des langages de programmation fonctionnels et académiques et à les apporter au grand public. De nombreuses langues ont eu des idées merveilleuses, mais elles ont finalement été rejetées comme ésotériques ou trop difficiles à apprendre et, par conséquent, ont eu du mal à rallier une large communauté autour d'elles. Grain espère donner une nouvelle vie à ces idées et les présenter sous une forme accessible, facile à utiliser et à comprendre.

Parmi les fonctionnalités empruntées aux langages fonctionnels par Grain nous trouvons l'inférence de types, avec un vérificateur de type à la Objective Caml, la correspondance de motifs, les fermetures (closures), les fonctions de première classes, c'est-à-dire des fonctions qui sont traitées comme n'importe quelle variable, et qui notamment peuvent être des arguments d'autres fonctions ou des valeurs retournées par d'autres fonctions, etc. Avec Grain, les variables sont mutables. Il ne s'agit donc pas d'un langage fonctionnel pur. Ses concepteurs ont fait ce choix pour donner de la flexibilité au langage.

Grain dispose d'une bibliothèque standard et d'un système de modules. La chaîne d'outils Grain (CLI, compilateur, runtime et bibliothèque standard) est livrée sous la forme d'un binaire unique. Les binaires sont disponibles pour MacOS x64 , Linux x64 et Windows x64. Une version JavaScript du compilateur Grain est disponible pour une utilisation dans les plates-formes où un binaire personnalisé n'est pas disponible.

Grain dispose d'un site dédié, grain-lang.org, sur lequel on trouve un guide de démarrage et une documentation complète.

Grain, en version 0.3 pour le moment, n'en est qu'à ses tous débuts. Le développement futur de Grain devrait inclure une meilleure interface de fonction étrangère pour invoquer du code natif, l'édition de liens statique, une bibliothèque standard DOM, des macros, etc.Grain est un logiciel libre sous licence GNU Lesser General Public License v3.0 disponible sur GitHub.

[video:https://www.youtube.com/watch?v=O8tyml3xBMG autoplay:0]

Au revoir programmation objet !

Soumis par fredericmazue le

A lire, ce très intéressant billet écrit par un développeur qui a des années d'expérience en programmation objet, et qui exprime ses déceptions avec ce paradigme de programmation, malgré l'enthousiasme qu'il avait au départ.

J'étais enthousiaste à l'idée de tirer parti des avantages de l'héritage , de l'encapsulation et du polymorphisme. Les trois piliers du paradigme. J'avais hâte d'obtenir la promesse de réutiliser et de tirer parti de la sagesse acquise par ceux qui m'ont précédé dans ce nouveau paysage passionnant. Je ne pouvais pas contenir mon excitation à l'idée de cartographier mes objets du monde réel dans leurs classes et je m'attendais à ce que le monde entier se mette parfaitement en place. Je n'aurais pas pu me tromper plus.

L'auteur du billet explique ensuite pourquoi à ses yeux les promesses de l'héritage, de l'encapsulation et du polymorphisme ne sont pas tenus. Non sans humour :

Le problème avec les langages orientés objet est qu'ils ont tout cet environnement implicite qu'ils transportent avec eux. Vous vouliez une banane mais ce que vous avez obtenu était un gorille tenant la banane et toute la jungle. (citation de Joe Armstrong, créateur d'Erlang)

Comme il est toujours bon pour un développeur de s'interroger et de se remettre en cause dans ses pratiques, ce billet mérite vraiment d'être lu. Bien sûr c'est un texte qui ne manquera pas de déclencher des réactions, ceci d'autant plus que l'auteur conclut son billet intitulé Au revoir programmation objet ! par Bonjour programmation fonctionnelle ! :-)

Commentaire actu

Membre depuis

14 ans 2 mois
labilbe

L'auteur soulève des points qui font echo en ce qui me concerne. C'est très bien formulé et expliqué alors que je trouve cet exercice extrèmement difficile. Merci à vous pour le partage.

mer, 2 Sep 2020 - 10:24 Permalien
Anonyme (non vérifié)

Franchement je en trouve pas cette article "très intéressant". Les exemples qu'il utilise pour justifier son rejet de la POO ne sont pas viables. Certe la programmation orienté objet ne protège pas d'une mauvaise utilisation. Il faut beaucoup d'expérience pour la maitriser. C'est bien le seul reproche qu'on pourrait lui faire. 

mer, 2 Sep 2020 - 13:29 Permalien
Anonyme (non vérifié)

en gros, il faut être expérimenté pour coder proprement en objet ... de là à rejeter toute la POO et sa puissance, vous êtes vraiment cinglé et débilisant ... 

jeu, 3 Sep 2020 - 13:40 Permalien

Membre depuis

20 ans 8 mois
fredericmazue

Réservez vos insultes pour l'auteur du billet. A Programmez! nous n'avons jamais dit qu'il fallait rejeter tout la POO. Nous avons simplement dit que le billet cité était intéressant et qu'il méritait d'être lu.

jeu, 3 Sep 2020 - 16:02 Permalien

Chaos : un langage pour une programmation en bon ordre ?

Soumis par admin le

Chaos est un nouveau langage de programmation. Il est au tout début de son développement et sa version actuelle est v0.0.1.alpha3. Néanmoins, ce langage n'est pas sans intérêt.

Chaos est un langage fonctionnel pur. Faillait-il un nouveau langage fonctionnel pur alors que d'autres, tels que Haskell par exemple, existent depuis des années et sont très peu utilisés ? Evidemment la question mérite d'être posée. Toutefois les amateurs de programmation fonctionnelle trouveront que Chaos est intéressant et qu'il mérite d'être découvert.

Chaos s'inspire de nombreux autres langages, y compris non fonctionnels. Ces influences sont, notamment :

  • La sécurité des types de TypeScript
  • Les syntaxe, modules et extensibilité de Python
  • Les boucles et blocs de Ruby
  • L'immuabilité de Haskell
  • La vitesse de C
  • l'arithmétique matricielle de NumPy
  • le moteur d'expressions régulières de Perl.

Choas n'a pas de structures de contrôle. (pas de if..else, pas de switch..case). La prise de décision n'est possible que sur les retours de fonction:

func myFunc(num a, num b)
     // votre code
end { x > 0 : f1(x), default : f2(x) }

Ainsi, un seul test unitaire suffit pour avoir une couverture à 100% sur les fonctions, toujours, soulignent les créateurs du langage.

Chaos dispose aussi d'un mécanisme d'extensions écrites en C et permet, selon ses créateurs, de dire adieu aux conflits de dépendance avec le gestionnaire de dépendance Occultist.

Chaos dispose aussi d'un shell interactif.

Chaos est un logiciel libre sous licence MIT, disponible sur GitHub.

Microsoft présente Bosque, un nouveau langage fonctionnel

Soumis par fredericmazue le

La semaine dernière, Mark Marron, de Microsoft Research, a présenté Bosque, un nouveau langage de programmation, dans un court billet : 

Le langage de programmation Bosque est conçu pour écrire du code simple, clair et facile à comprendre pour les humains et les machines. Les principales caractéristiques de conception du langage permettent d'éviter toute complexité accidentelle dans le processus de développement et de codage. L'objectif est d'améliorer la productivité des développeurs, d'améliorer la qualité des logiciels et de proposer une gamme de nouveaux compilateurs et de nouvelles expériences d'outils de développement.

Mark Marron présente par ailleurs Bosque dans un document technique de 18 pages qui nous apprend entre autres que ce langage dérive d'une combinaison de TypeScript, de ML, ainsi que de Node/JavaScript.

Le projet Bosque est sur GitHub. Bosque est un langage open source sous licence MIT. Les développeurs sont invités à s'impliquer dans le projet et/ou à faire leurs commentaires. La page GitHub détaille toutes les fonctionnalités du langage. Mais quelques paragraphes restent à écrire. 

Le coup du langage clair et facile, on nous l'a déjà fait. Celui du langage sûr qui évite les erreurs également :-) Bosque apporte-t-il vraiment quelque chose de nouveau et de pertinent dans ces domaines ? C'est un peu la question.

Bosque est un langage fonctionnel pur. Cela signifie qu'il ne permet pas les affectations. Toutes les valeurs sont immuables, ce qui permet d'éviter les effets de bord, donc de nombreuses erreurs de programmation effectivement. Comme pour tous les langages fonctionnels, les fonctions sont des valeurs de premier ordre, ce qui signifie quelles peuvent être passées en arguments à d'autres fonctions, ou retournées par des fonctions.

Mark Marron souline que Bosque élimine la complexité des boucles des langages impératifs. Par exemple ce code JavaScript :

//Imperative Loop (JavaScript)
var: number[] a = [...];
var: number[] b = [];
/**
Pre: b.length == 0
**/

for(var i = 0; i < a.length; ++i) {
    /**
    Inv: b.length == i /\
      forall i in [0, i) b[i] == a[i]*2
    **/
  b.push(a[i]*2);
}

/**
Post: b.length == a.length /\
  forall i in [0, a.length) b[i] == a[i]*2
**/

Trouve son équivalent en Bosque :

//Functor (Bosque)
var a = List[Int]@{...};
/**
Pre: true
**/
var b = a.map[Int](fn(x) => x*2);
/**
Post: List[Int]::eq(fn(x, y) => y == x*2, a, b)
**/

Concrètement, pour nos lecteurs peu familiers avec la programmation fonctionnelle, une fonction lambda qui retourne le double de son argument est mappée sur une liste, c'est-à-dire appliquée sur chaque élément de la liste. Programmation fonctionnelle pure oblige, la liste de départ, ici a, n'est pas modifiée. L'opération retourne une nouvelle liste b en guise de résultat.

Ce nouveau langage apporte-t-il vraiment quelque chose ? De l'humble avis de votre serviteur, grand amateur de programmation fonctionnelle pure, pas grand chose. Est-ce que quelqu'un avait vraiment besoin d'un autre langage Clean, Mercury ou Haskell ? Rien n'est moins certain. La présentation de Mark Marron ne s'étend pas beaucoup sur deux pierres d'achoppement des langages fonctionnels purs incontournables dans les applications pratiques : les entrées/sorties et la programmation concurrente. Haskell, par exemple, résout le problème avec élégance au moyen des monades. Le moins que l'on puisse dire est que la présentation de Mark Marron ne s'étend pas sur le sujet.

La page GitHub du projet Bosque donne un programme de TicTacToe comme exemple concret complet. Dans le code, on voit un tableau de positions gagnantes déclaré comme ceci :

const winPositionOptions: List[List[[Int, Int]]] = List[List[[Int, Int]]]@{
    List[[Int, Int]]@{ @[ 0, 0 ], @[ 0, 1 ], @[ 0, 2 ] },
    List[[Int, Int]]@{ @[ 0, 1 ], @[ 1, 1 ], @[ 2, 1 ] },
    List[[Int, Int]]@{ @[ 0, 2 ], @[ 1, 2 ], @[ 2, 2 ] },

    List[[Int, Int]]@{ @[ 0, 0 ], @[ 1, 0 ], @[ 2, 0 ] },
    List[[Int, Int]]@{ @[ 1, 0 ], @[ 1, 1 ], @[ 1, 2 ] },
    List[[Int, Int]]@{ @[ 2, 0 ], @[ 2, 1 ], @[ 2, 2 ] },

    List[[Int, Int]]@{ @[ 0, 0 ], @[ 1, 1 ], @[ 2, 2 ] },
    List[[Int, Int]]@{ @[ 0, 2 ], @[ 1, 1 ], @[ 2, 0 ] }
};

Ce code est-il vraiment clair et facile à relire pour un humain ? La redondance de la déclaration des types nous parait au contraire assez lourde. Les listes et les tuples sont déclarés par @ {...} et @ [...] respectivement. En Haskell c'est  [...] et (...) respectivement, ce qui n'est pas plus mal :-) 

Un jeu de Tetris écrit en Haskell

Soumis par fredericmazue le

A découvrir par ceux qui aiment le beau code. A découvrir également par ceux qui sont convaincus que les langages fonctionnels purs sont des langages ésotériques qui ne permettent pas vraiment de résoudre des problèmes pratiques.

A découvrir aussi pour ceux qui veulent de délasser entre deux séances d'écriturede code, ou à l'insu de leur chef de projet :-) Car ce Tetris se lance par une simple commande dans un terminal Linux ou macOS et permet de jouer dans ce même terminal.

Ce Tetris en Haskell est développé par Sam Tay. C'est un logiciel libre, disponible sur GitHub.

Intellij IDEA 15 supporte Kotlin

Soumis par fredericmazue le
IDE

JetBrains a annoncé la disponibilité de Intellij IDEA, 15ème du nom. Cette mouture propose une interface utilisateur améliorée, avec notamment une assistance au codage uniformisée, pour l'ensemble des langages pris en charge par l'EDI.

Intellij IDEA 15 supporte d'ailleurs un langage supplémentaire, en la personne de Kotlin. Kotlin est un langage de programmation fonctionnelle et orientée objet, avec typage statique. Son code compilé cible la JVM ou JavaScript.

Kotlin est un langage conçu par une équipe de JetBrains, l'éditeur d'Intellij IDEA.

Source : developpez.com

Haskell for Mac

Soumis par fredericmazue le

Haskell for Mac est un outil qui permettra aux possesseurs un Mac avec OS Yosemite de programmer en Haskell. L'outil est sur le Mac App Store au prix de 19,99 euros. L'outil propose des librairies graphiques 2D intéressantes.

Pour mémoire, Haskell est un langage fonctionnel pur. En tant que tel il permet d'écrire des programmes prouvés,  c'est-à-dire qui fonctionnent comme on s'y attend :-) Les langages ML permettant la même chose également.

Avec Haskell, tout, absolument tout est fonction mathématique. Les fonctions sont bien sûr des valeurs de premier ordre du langage. Haskell introduit notamment le concept de monade pour traiter les entrées/sorties de façon fonctionnelle. Outre les entrées/sorties, sa monade Maybe qui permet de déclarer quelque chose qui peut être ou ne pas être a quelque chose d'unique.

Extrêmement expressif, Haskell permet d'écrire du code très clair et concis.

Il est vrai que la courbe d'apprentissage de ce langage est assez raide, pour ne pas dire très raide. Il n'est pas toujours facile d'oublier les (mauvaises) habitudes prises avec les langages impératifs ou objets. Mais quand on y a goûté, on devient fan :-) De l'humble avis de votre serviteur, avec Haskell, des mots comme élégance et beauté prennent tout leur sens en informatique :-)

Programmez! a présenté Haskell plusieurs fois. Notamment dans Programmez! 146 et dans Programmez! 104 et 105 

Mozilla finalise son langage Rust qui arrive en version 1.0

Soumis par fredericmazue le

Rust est un projet qui a 6 ans, et que Mozilla a fait connaître publiquement il y a 5 ans. Rust est un langage compilé qui veut assurer la performance et la sureté de programmation. Le 15 mai 2015, Mozilla a annoncé la version 1.0 de Rust.

Encore un qui dit ça... il n'est pas le premier :-) Alors comment Rust se distingue-t-il ? Selon Mozilla, Rust veut concurrencer C et C++ sur leur terrain favori : la performance, avec une finesse sur le contrôle de ce qui se passe au plus bas niveau. D'ailleurs, d'emblée, la FFI (Foreign Function Interface) de Rust, c'est-à-dire son interface avec du code C existant et les librairies écrites en C, a été particulièrement soignée. Mais Rust veut aussi être un langage de haut niveau lorsque l'on code, être expressif et être adapté aux projets difficiles.

Pour cela, Rust est multi paradigmes. Il supporte la programmation impérative, la programmation objet, et la programmation fonctionnelle. Il emprunte beaucoup à cette dernière, parmi les langages fonctionnels que sont Haskell ou les langages de la famille ML.

En fait, quand on regarde Rust, on ne peut s'empêcher de penser que c'est dommage de créer le langage que l'on avait déjà en la personne d'Objective Caml. Langage de grande qualité, français (petit cocorico au passage :-) très performant et très sûr à la programmation. C'est ainsi que si Objective Caml peine (c'est peu dire) à gagner en popularité, il est utilisé pour les projets très difficiles et notamment l'écriture de compilateurs. D'ailleurs les tous premiers compilateur Rust ont été écrits en Objective Caml. A tout seigneur, tout honneur.

Bref, Mozilla réinvente Objective Caml, en insistant sur la qualité de la gestion de la mémoire de Rust. Rust suit la propriété d'une zone mémoire et le temps de vie des objets dès la compilation nous dit-on. Un objet alloué ne peut avoir qu'un seul propriétaire, et Rust s'assure que le propriétaire a un temps de vie au moins aussi long que sa propriété.

Rust est un langage multi-thread qui supporte donc la programmation concurrente. Il est disponible pour Windows, Linux et Mac OS X. Le code source de Rust est sur GitHb.

Pour saluer ce nouveau langage, sacrifions à la tradition :-)

fn main() {

    println!("Hello World!");

}

Ur/Web : un langage fonctionnel coordonateur pour des applications Web plus sûres et plus faciles à écrire

Soumis par fredericmazue le

Ecrire une application Web implique de maîtriser plusieurs technologies : HTML, CSS,JavaScript, JSON et/ou XML, un langage côté serveur, SQL, etc.

En outre, avec les technologies actuelles, les applications Web peuvent être particulièrement sensibles aux effets de bord. Par exemple, du code JavaScript devant gérer normalement une partie d'une page Web peut très bien écraser des variables dont dépend une autre partie de la même page.

A partir de ces constats et dans l'intention de remédier à ces inconvénients, Adam Chlipala, chercheur du MIT, propose Ur/Web.

Ur/Web a pour propos d'apporter des performances aux applications Web, car le code est compilé en code natif. Il a pour propos de simplifier le développement. Ainsi, il va automatiquement empaqueter les données échangées sur le réseau dans du XML. Il va générer le CSS nécessaire à la bonne apparence des pages, il va encore injecter aux bons endroits du 'bon code' JavaScript dans les pages. Bon code se comprenant par du code JavaScript qui ne risquera pas de provoquer des effets de bords. Ur/Web peut donc être vu comme un langage coordonateur des multiples technologies impliquées dans le développement d'une applications Web.

Présenté ainsi, Ur/Web a de quoi séduire les développeurs. D'autant plus qu'il propose un modèle de programmation concurrente pour gérer les communications complexes entre clients et serveurs.

Est-ce que Ur/Web séduira les développeurs ? En dépit des qualités indéniables que le langage présente, rien n'est moins sûr.

Car Ur/Web comme le nom le suggère, dérive du langage fonctionnel Ur. Ur/Web est donc un langage fonctionnel dont le code ressemble à du code Haskell. Haskell est un langage absolument génial, mais universellement qualifié d'ésotérique. Il est vrai que la courbe d'apprentissage de Haskell est assez raide.

Il n'y a donc rien d'étonnant à ce que Adam Chlipala lui-même indique que la courbe d'apprentissage de Ur/Web est "un peu difficile".

Incontestablement, la programmation fonctionnelle, en dépit de tous les avantages qu'elle peut présenter en ce qui concerne l'expressivité et la sûreté dans l'écriture du code peine à s'imposer. Sans doute en grande partie pour des raisons pédagogiques, elle fait même plutôt figure d'épouvantail. C'est pourquoi Ur/Web risque de rester un langage confidentiel.

Mais Ur/Web n'en est pas moins un  langage très intéressant que vous pouvez découvrir dans ce document qui en présente l'essentiel et contient des didacticiels.

Ci-dessous, afin de vous donner une idée de ce qu'est Ur/Web, extrait du document de présentation mentionné, le code qui servirait de base à une chat room :

table room : { Id : int, Title : string }
table message : { Room : int, When : time, Text : string }

fun chat id = let
  fun say r =
   dml (INSERT INTO message (Room, When, Text)
     VALUES ({[id]}, CURRENT_TIMESTAMP, {[r.Text]}));
   chat id
in
  title <− oneRowE1 (SELECT (room.Title) FROM room
                                      WHERE room.Id = {[id]});
   log <− queryX1 (SELECT message.Text FROM message
                                       WHERE message.Room = {[id]}
                                       ORDER BY message.When)
                                    (fn r => <xml>{[r.Text]}<br/></xml>);
   return <xml><body>
     <h1>Chat Room: {[title]}</h1>
 

   <form>
     Add message: <textbox{#Text}/>
    <submit value="Add" action={say}/>
     </form>
     <hr/>

 {log}
 </body></xml>
  end

fun main () =
  rooms <− queryX1 (SELECT * FROM room
                              ORDER BY room.Title)
                 (fn r => <xml><li><a link={chat r.Id}>
                                  {[r.Title]}</a></li></xml>);
   return <xml><body>
   <h1>List of Rooms</h1>

   {rooms}
  </body></xml>

Atelier Event Sourcing en F# au MUG Lyon

Soumis par fredericmazue le

Le MUG Lyon organise un atelier "Event Sourcing en F#" animé par Jérémie CHASSAING, suivi d'un afterwork; ces évènements sont gratuits et ouverts à tou(te)s. 

Domain Driven Design (DDD), Event Sourcing et F#: L'alliance Parfaite !!!

En stockant l'histoire du système plutôt que son état actuel, l'Event Sourcing est une technique radicale pour implémenter DDD efficacement. Mais beaucoup s'arrêtent avant d'avoir commencé, convaincu qu'une telle solution sera difficile à mettre en œuvre.

Un exemple court en F# montrera comment implémenter l'Event Sourcing de façon simple, claire et "production ready", en laissant la plus grosse part à un code métier devenu limpide.

Aucune connaissance préalable en F# n'est requise.

Le 25 septembre 2014

Sciences-U
53 Cours Albert Thomas
69008 Lyon
France

S'inscrire