Lorsque je découvre ou veux expliquer un concept, j'aime assez m'appuyer sur un Kata, un exercice court pour mettre en avant une pratique de programmation. Je vous propose donc le DnD Kata, dont l'objectif est de modéliser une équipe de personnages pour une partie du jeu de rôles Donjons et Dragons. Bien sûr modéliser l'ensemble des règles est un exercice complexe, nous nous contenterons ici de représenter un personnage par :

• son nom
• sa race
• ses compétences, en incluant bien sûr ses bonus raciaux

Une équipe est une collection de personnages, pouvant être de race différente.

L'objectif pédagogique de ce kata est d'illustrer les foncteurs OCaml et de démontrer comment ils contribuent à appliquer les principes S.O.L.I.D en OCaml.

Les plantages d'un programme à l'exécution sont très coûteux, surtout lorsqu'ils se produisent en production : arrêt du service, interruption d'un traitement, perte de données, ...

Dans ce billet nous allons passer en revue les différents mode de gestion des erreurs, et comment les traiter avec ReasonML.

Irmin est une base de données clé / valeur, créée pour pouvoir être distribuée facilement. Elle suit les principes de Git et est codée en OCaml. Une promesse suffisament intéressante pour y consacrer un billet.

ReasonML natif dispose d'un outillage exceptionnel, grâce à l'ecosystème OCaml. Dans ce billet, je vous propose de créer depuis 0 un projet ReasonML natif. Nous parcourerons l'outillage de gestion de dépendance, de construction logicielle, de travail dans un bac à sable par projet.

ReasonML intègre un système de programmation modulaire. Les modules offrent un mécanisme d'encapsulation et permettent d'organiser le code en unités logiques, en fournissant des espaces de noms (namespaces) utiles lors de leur utilisation. ReasonML propose un système de modules récursifs et paramétrables très puissant qui permet de fournir une grande généricité au code.

En ReasonML, tout le code est encapsulé dans des modules. Si nous plaçons l'ensemble du code du premier billet dans un fichier Hero.re, cela définit automatiquement un module Hero.

Les types de données algébriques, en anglais algebraic data types ou ADT, sont une classe de types de données composites, c'est à dire de nouveaux types créés dans un langage de programmation à partir de primitives de types.

On distingue principalement 4 types d'ADT issus de la théorie des catégories : les types sommes, les types produits, les types exponentiels et les type récursifs. ReasonML permet de définir de nouveaux types permettat de modéliser les ADT, nous allons voir comment et leur intérêt.

Je me lance dans l'exercice de la série d'article. Pour commencer, je souhaite partager avec vous un langage et un ecosytème qui me passionne depuis 3 ans ReasonML

Si vous ne connaissez pas encore ce langage, il s'agit d'une syntaxe de OCaml développée au sein de Facebook par Jordan Walke, le papa de ReactJS. Facebook n'en est pas à ses début avec l'écosystème OCaml puisque ce dernier a notament servi à réaliser le prototype de react avant de passer sur Javascript pour des raisons marketing, à réaliser la machine virtuelle PHP/Hack HHVM ou encore à réaliser le typechecker javascript Flow

Je travaille actuellement sur un robot compagon nommé Cutii pour lequel nous avons besoins de communiquer sur port série entre le PC du robot et nos différentes cartes électronique, nous avons fait le choix il y a quelques mois d'implémenter une librairie de communication en Rust, afin de rendre plus sûrs et plus performants nos échanges. Ce billet vise à dresser un état des lieux de la gestion de communications asynchrones en Rust.

Pour illustrer les exemples, imaginons que nous ayons un protocole simplifié de communication, nous permettant de faire des GET et SET sur des valeur, en mode requête / réponse et sur port série :

# requête GET pour une valeur foo
foo?\n
# réponse à la requête GET
foo=1\n
# requête SET pour une valeur foo
foo=2\n
# réponse d'acquitement à la requête SET
foo=2\n

Si vous êtes développeur Node.js, vous vous confronterez tôt ou tard au développement d'addons natifs ... et à tout un lot de nouveaux problèmes : le langage C++ en lui même, mais également API V8, build system ou dépendance aux versions de V8. Pourtant dès que vous avez besoins de multi-threading, d'accès aux ressources machine ou même simplement pour réutiliser des librairies existantes vous n'y coupez pas. Ce billet vise à vous faire découvrir comment le langage Rust permet de rendre vos modules natifs "fast & safe".

L'absence d'opérateur de composition, similaire au . de Haskell, ou de pipeline similaire au |> de ReasonML et OCaml, est assez frustrante lors qu'on essaie de faire du code Rust déclaratif.

Il est possible d'envisager la dot notation mais, d'une part ce n'est pas totalement satisfaisant et, d'autre part cela nécessite d'implémenter des traits pour chacun des types de données qui composent le flux de traitement.