tuto_fonctionnel

Episodes

1. 20

   IA de jeux, Conclusion

   https://nokomprendo.gitlab.io/posts/tuto_073/2021-05-23-fr-README.html Cet article conclut la série consacrée à l’implémentation d’un jeu de Puissance 4 et de quelques Intelligences Artificielles, en C++ et en Haskell. Il résume les points abordé...

   Jul 25, 2021
2. 19

   IA de jeux, Performances de code, en Haskell

   https://nokomprendo.gitlab.io/posts/tuto_072/2021-05-22-fr-README.html Cet article, de la série “IA de jeux”, aborde les performances d’exécution en Haskell. En effet, Haskell peut produire du code natif relativement rapide mais cela nécessite ...

   Jul 24, 2021
3. 18

   IA de jeux, Implémenter une IA arborescente, en Haskell

   https://nokomprendo.gitlab.io/posts/tuto_071/2021-05-21-fr-README.html Cet article, de la série “IA de jeux”, présente une implémentation de l’algorithme Monte-Carlo Tree Search, en Haskell, pour le jeu Puissance 4. Cette implémentation est ens...

   Jul 17, 2021
4. 17

   IA de jeux, Implémenter une IA basique, en Haskell

   https://nokomprendo.gitlab.io/posts/tuto_070/2021-05-20-fr-README.html Cet article, de la série “IA de jeux”, aborde la mise en place d’une intelligence artificielle, en Haskell : bots simples, comparaison, interface utilisateur. Pour cela, on ...

   Jul 3, 2021
5. 16

   IA de jeux, Implémenter un Puissance 4, en Haskell

   https://nokomprendo.gitlab.io/posts/tuto_069/2021-05-19-fr-README.html Cet article, de la série “IA de jeux”, aborde l’implémentation d’un Puissance 4, en Haskell. Afin de pouvoir comparer avec l’implémentation C++ des articles précédents, il p...

   Jun 13, 2021
6. 15

   IA de jeux, Performances de code, en C++

   https://nokomprendo.gitlab.io/posts/tuto_068/2021-05-18-fr-README.html Cet article, de la série “IA de jeux”, présente et illustre quelques méthodes et outils qu’il peut être intéressant d’utiliser pour améliorer les performances d’un code (ou pa...

   Jun 2, 2021
7. 14

   IA de jeux, Implémenter une IA arborescente, en C++

   https://nokomprendo.gitlab.io/posts/tuto_067/2021-05-17-fr-README.html Cet article, de la série “IA de jeux”, présente l’algorithme de Monte-Carlo Tree Search, pour le jeu de Puissance 4. Il explique tout d’abord la notion d’arbre de jeux puis l’...

   May 30, 2021
8. 13

   IA de jeux, Implémenter une IA basique, en C++

   https://nokomprendo.gitlab.io/posts/tuto_066/2021-05-16-fr-README.html Cet article, de la série “IA de jeux”, aborde la mise en place d’une intelligence artificielle. Il se base sur le jeu de Puissance 4 implémenté dans l’article précédent mais...

   May 30, 2021
9. 12

   IA de jeux, Implémenter un Puissance 4, en C++

   https://nokomprendo.gitlab.io/posts/tuto_065/2021-05-15-fr-README.html Cet article, de la série “IA de jeux”, aborde l’implémentation d’un Puissance 4, en C++. Il rappelle d’abord les règles du jeu, les fonctionnalités à implémenter et les diff...

   May 25, 2021
10. 11

    IA de jeux, Introduction

    https://nokomprendo.gitlab.io/posts/tuto_064/2021-05-14-fr-README.html Cet article est le premier d’une série consacrée à l’implémentation d’un jeu de Puissance 4 et de quelques Intelligences Artificielles. L’objectif est à la fois d’aborder le...

    May 24, 2021
11. 10

    Implémenter un DSL de HTML, en Haskell

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_63/2021-04-27-fr-README.html Cet article résume et illustre les notions vues dans les articles précédents sur un exemple concret, implémenter un DSL pour générer du HTML simplifié. Il présent...

    Apr 28, 2021
12. 9

    L'approche Tagless Final, en Haskell

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_62/2021-04-16-fr-README.html L’approche Tagless Final est une façon classique d’organiser du code. Elle permet notamment d’implémenter des DSL ou de compléter le pattern ReaderT. Grossière...

    Apr 19, 2021
13. 8

    Le design pattern ReaderT, en Haskell

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_61/2021-04-02-fr-README.html Le design pattern ReaderT est une architecture de code classique en Haskell. Elle permet de séparer la couche métier de l’environnement d’exécution, tout en expli...

    Apr 9, 2021
14. 7

    Monade State, Transformateur et MTL, en Haskell

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_60/2021-03-29-fr-README.html Au tutoriel 59, on a vu comment utiliser les transformateurs de monade pour “empiler” les fonctionnalités voulues, via le système de types. On va maintenant détai...

    Apr 1, 2021
15. 6

    tuto fonctionnel 59 : Introduction aux transformateurs de monades, en Haskell

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_59/2021-03-19-fr-README.html En Haskell, une monade permet de définir une suite d’actions dans un contexte particulier (par exemple, des entrées/sorties, des communications HTTP, des calculs ...

    Mar 22, 2021
16. 5

    tuto fonctionnel 58 : Introduction aux DSL, en Haskell

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_58/2021-03-14-fr-README.html Cet article introduit les DSL (ou langages dédiés, en français) et en quoi Haskell est intéressant pour les mettre en œuvre.

    Mar 18, 2021
17. 4

    tuto fonctionnel 57 : Parsing et monade, en Haskell

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_57/2021-03-06-fr-README.html Précédemment, on a vu comment Haskell implémente des structures évoluées comme Functor, Applicative et Monad. On va maintenant voir comment utiliser ses structure...

    Mar 7, 2021
18. 3

    tuto fonctionnel 56 : Foncteur, applicative et monade, en Haskell

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_56/2021-02-26-fr-README.html Les foncteurs, les applicatives et les monades sont des structures permettant d’ajouter des fonctionnalités particulières à des types (par exemple, appliquer une ...

    Feb 28, 2021
19. 2

    tuto fonctionnel 55 : Introduction à DeriveGeneric en Haskell, exemple avec le format JSON

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_55/2021-02-17-fr-README.html En Haskell, DeriveGeneric est une fonctionnalité qui analyse la définition d’un type. Ceci permet de générer automatiquement des instances de classe de type. Plus...

    Feb 21, 2021
20. 1

    tuto fonctionnel 54 : Classes de types et Functor, en Haskell

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_54/2021-02-13-fr-README.html En plus des types algébriques (ADT), Haskell supporte les classes de types (Type Classes). Celles-ci permettent notamment de spécifier des contraintes sur des typ...

    Feb 14, 2021
21. tuto fonctionnel 45 : NixOS 20.09 - Présentation, installation, configuration, utilisation

    NixOS est une distribution linux, plutôt atypique, basée sur le gestionnaire de paquets Nix. Elle utilise une approche déclarative pour définir des environnements logiciels, de façon reproductible et composable. À l’occasion de la sortie récent...

    Nov 14, 2020
22. tuto fonctionnel 41 : Comprendre Go en 5 minutes, en Haskell

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_41/2019-12-21-fr-README.html Erratum : le code pour les processus légers ne correspond pas tout à fait. Voir l'article. D’après leur réputation, Go et Haskell sont des langages de programmat...

    Dec 22, 2019
23. tuto fonctionnel 40 : Gérer son environnement utilisateur NixOS, avec Home-manager

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_40/2019-11-12-fr-README.html Home-manager est un outil qui permet de gérer son environnement utilisateur : environnement de bureau, thème de fenêtre, thème d’icones, logiciels, paramètres des...

    Nov 11, 2019
24. tuto fonctionnel 39 : Étendre ou modifier sa logithèque Nix avec les overlays

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_39/2019-11-11-fr-README.html Le gestionnaire de paquets Nix est hautement personnalisable. Pour cela, il reprend le principe de la composition de fonctions : un paquet est en fait une fonctio...

    Nov 10, 2019
25. tuto fonctionnel 37 : NixOS 19.09

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_37/2019-11-09-fr-README.html NixOS est une distribution Linux basée sur Nix, un gestionnaire de paquets évolué. Nix permet à un utilisateur de créer des environnements logiciels personnalisés...

    Nov 10, 2019
26. tuto fonctionnel 38 : Cachix, un service de cache binaire basé sur Nix

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_38/2019-11-10-fr-README.html Cachix permet de gérer facilement un cache personnel de paquets binaires. Concrètement, il s’agit d’un service de cloud et d’un logiciel client, le tout basé sur ...

    Nov 10, 2019
27. tuto fonctionnel 35 : Introduction aux templates C++

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_35/2019-11-01-fr-README.html En C++, un template permet de paramétrer du code (fonction, structure, classe) selon un “type générique”. On peut ensuite spécifier un “type concret” que doit pre...

    Nov 3, 2019
28. tuto fonctionnel 36 : Les templates variadiques en C++

    https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_36/2019-11-02-fr-README.html Les templates variadiques sont des templates qui peuvent recevoir un nombre variable de paramètres. On peut donc les voir comme l’équivalent des fonctions variadi...

    Nov 3, 2019
29. tuto fonctionnel 19 : Créer et partager des paquets Nix

    Nix permet facilement de : créer des paquets localement, regrouper des paquets dans un dépôt, soumettre des paquets à la communauté, tester des paquets soumis, https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_19/2018-04-25-READM...

    Jul 30, 2019
30. tuto fonctionnel 17 : Migrer un système NixOS (de 17.09 à 18.03)

    Nix : système de paquets. NixOS : distribution linux utilisant Nix + un système de services. Nix/NixOS utilise un système de versions (deux versions par an) + un canal unstable pour le développement. Changer de version ou de canal se fait a...

    Jul 30, 2019
31. tuto fonctionnel 16 : Développement web en Haskell

    Haskell est bien adapté au développement web côté-serveur : nombreuses bibliothèques, avantages du typage fort… Objectif de ce tutoriel : exemple d’application web pour gérer une “TODO list”. Fonctionnalités à mettre en oeuvre : serveur web ave...

    Jul 30, 2019
32. tuto fonctionnel 18 (HS) : Archlinux vs Voidlinux

    Archlinux et Voidlinux sont des distributions linux rolling-release pour utilisateurs “intermédiaires” (non-allergiques à la ligne de commande). Leurs objectifs sont proches mais leurs choix techniques assez différents. Objectifs de cette prése...

    Jul 30, 2019
33. tuto fonctionnel 15 : Développement/déploiement web (apache, php, postgresql) avec nixops

    Un site web “classique” nécessite souvent un serveur web + php et une base de données. Problèmes : mise en place non-triviale pour le développeur, mise en place à refaire pour déployer le site final, travail sur plusieurs sites web… Solutions : do...

    Jul 30, 2019
34. tuto fonctionnel 14 : liaison de fonction dynamique (ou pas)

    Comment appeler des fonctions sur des collections hétérogènes. Par exemple : type Forme + sous-types Carre et Rectangle, fonctions surface. https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_14/2018-03-04-README.html

    Jul 30, 2019
35. tuto fonctionnel 13 : curryfication et évaluation partielle (javascript/haskell)

    Comment écrire des fonctions curryfiée et faire de l'évaluation partielle en Javascript et en Haskell. https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_13/2018-02-25-README.html

    Jul 30, 2019
36. tuto fonctionnel 20 : Nix, programmation et loi de Murphy

    Quand on développe un logiciel on utilise très souvent des bibliothèques, ce qui peut apporter de nombreux problèmes : bibliothèque fournie par le système ou à compiler manuellement, version compatible avec le projet, options de compilation, déplo...

    Jul 30, 2019
37. tuto fonctionnel 21 : Déployer un blog avec Hakyll, Gitlab-ci, Nix

    Comment générer un blog avec Hakyll et le publier avec des outils modernes de gestion de code source et d'intégration continue. https://nokomprendo.gitlab.io/posts/tuto_fonctionnel_21/2018-06-10-README.html

    Jul 30, 2019
38. tuto fonctionnel 24 : Développement web frontend en Haskell, Elm et Purescript

    Actuellement, le développement web côté-client (frontend) est très souvent réalisé en JavaScript ou dans des langages dérivés comme TypeScript. Il existe cependant d’autres outils intéressants, basés sur des langages de programmation fonctionnelle...

    Jul 30, 2019
39. tuto fonctionnel 25 : Un serveur de webcam en 35 lignes de Haskell

    Pour mettre en place une webcam, on connecte une caméra à un ordinateur sur lequel on fait tourner un serveur retransmettant les images. Celles-ci sont alors accessibles via des requêtes au serveur. Cet article présente comment implémenter un ...

    Jul 30, 2019
40. tuto fonctionnel 26 : Installer Node.js sur Debian : binaires, Nix ou Docker ?

    Node.js est un outils très classique pour développer des applications web côté-serveur en JavaScript. La version LTS actuelle de Node.js est la 8. Malheureusement, Debian (Stretch) propose seulement la version 4, sans le gestionnaire de paquets NP...

    Jul 30, 2019