Erlang programmation

Table of contents

1. Couverture
2. Le résumé et la biographie auteur
3. Page de titre
4. Copyright
5. Table des matières
6. Préface, par Joe Armstrong, créateur du langage Erlang
7. Remerciements
8. Avant-propos
9. Première partie: Le langage erlang
   1. Chapitre 1: Présentation et installation d’Erlang
      1. Présentation d’erlang
         1. Bénéfices à l’exploitation : la haute disponibilité des applications
         2. Productivité et confort de développement
         3. Diffusion et pérennité du langage
         4. Bénéfices pour une utilisation industrielle
      2. Installation et premiers contacts
         1. Téléchargement des fichiers de distribution Erlang/OTP
         2. Installation d’erlang/OTP
         3. Installation sur d’autres systèmes à partir des sources
         4. Vérification de l’installation
         5. Installation de la documentation
         6. Prise en main
      3. Conclusion
   2. Chapitre 2: Grands principes du langage
      1. L’omniprésence des fonctions
      2. La place de la récursivité
      3. L’affectation unique des variables
         1. Appréhender l’affectation unique des variables
      4. La correspondance de motifs
         1. Trois exemples faciles
      5. Les variables et types
         1. Syntaxe
         2. Comparaison avec les systèmes de typage de java et python
      6. Les types élémentaires
         1. Les entiers
         2. Les réels
         3. Les atomes
         4. Les identifiants de processus
         5. Les références
         6. Opérations sur les types élémentaires
      7. Types composés et structures de données
         1. Les listes
         2. Les tuples
         3. Les structures (« records »)
         4. Le type binaire
      8. Conclusion
   3. Chapitre 3: Construire et structurer un programme Erlang
      1. Organisation en fonctions, modules et paquetages
         1. Les modules pour organiser et réutiliser
         2. Les fonctions
         3. Les paquetages
      2. Définition de la logique applicative : approche fonctionnelle de la programmation séquentielle
      3. Traitements à base de listes et de tuples
         1. Concaténation de listes
         2. Accumulation de valeurs en tête de liste
         3. L’aplatissement de listes
         4. Conversion entre tuples et listes
         5. Emballage et déballage de tuples
         6. Les générateurs de listes (List comprehensions)
      4. Les structures de contrôle
         1. Les boucles
         2. Les traitements conditionnels
      5. Conclusion
   4. Chapitre 4: La programmation concurrente
      1. Les processus
         1. Création d’un processus
         2. Exécution d’un processus
         3. Les « exports internes »
         4. Fin d’un processus
         5. Le cycle de vie d’un processus
         6. Processus légers
      2. Communication entre processus : le passage de messages
         1. L’envoi d’un message
         2. La réception d’un message
         3. Les processus nommés
      3. Conclusion
   5. Chapitre 5: Gestion des erreurs
      1. L’interception et le traitement des erreurs d’exécution
         1. L’interception d’une erreur d’exécution : l’instruction catch
         2. Le déclenchement d’une erreur : les instructions throw et exit
         3. Correspondance de motifs et valeur de retour des fonctions
         4. Recommandations d’usage
      2. Séparations du code de traitement d’erreur et de la logique applicative
         1. Laisser le programme « planter » ! (Let it crash !)
         2. Mécanisme de propagation des erreurs
         3. Processus superviseurs et processus travailleurs
         4. Le traitement de la propagation des erreurs
      3. Le débogage
         1. Utilisation du débogueur standard
         2. Le fichier erl_crash.dump
         3. Style du code et méthodologie de développement
      4. Conclusion
10. Deuxième Partie: Le développement d’applications Erlang
    1. Chapitre 6: Erlang/OTP : le framework de développement d’applications
       1. Les comportements
          1. Principe de fonctionnement
          2. Implémentation d’un comportement dans un module
       2. Mise en œuvre du framework erlang/OTP
          1. Notre serveur développé en Erlang
          2. La version erlang/OTP de notre serveur
          3. Le superviseur
          4. Tester l’efficacité de notre superviseur
          5. Le packaging de l’application
          6. Visualiser l’arbre des processus
          7. La distribution de l’application
          8. La mise à jour à chaud de notre application
       3. Conclusion
    2. Chapitre 7: L’environnement de développement
       1. Les principaux éléments
          1. La machine virtuelle
          2. Les fichiers source
          3. La compilation
       2. Le cycle de développement
       3. Le shell erlang
       4. L’éditeur de code : le mode Erlang pour (X)Emacs
          1. Installation sous windows
          2. Configuration
          3. Utilisation de l’environnement de développement (X)Emacs/Erlang
       5. Configuration et personnalisation de l’environnement
          1. Le fichier .erlang
          2. user_default et shell_default
       6. Les extensions au mode Erlang pour Emacs : Distel
       7. Eclipse : la perspective Erlang
       8. Conclusion
    3. Chapitre 8: Les bases de données
       1. La base de données mnesia
          1. Un exemple simple
          2. Importance et signification de la clé dans une table
          3. Le schéma de base de données
          4. Insertions
          5. Sélections d’enregistrements et requêtes
          6. Suppression d’enregistrements
       2. Déclencheurs et contrôles d’intégrité avec Mnesia
       3. Utilisation des fonctionnalités de distribution de Mnesia
          1. Répartition des tables sur des nœuds différents
          2. Réplication d’une table sur plusieurs nœuds
       4. Fragmentation d’une table sur plusieurs nœuds
       5. Sauvegarde et restauration
       6. Conclusion
    4. Chapitre 9: Le développement d’interfaces graphiques
       1. Erlang et les outils de développement d’interface utilisateur
       2. Le développement d’interfaces graphiques en TK
          1. Une application « helloworld » graphique
          2. Principes de fonctionnement de l’application GS
          3. Le traitement des événements
          4. Les options des objets graphiques
          5. Quelques éléments graphiques fondamentaux
          6. L’organisation automatique de l’interface : le packer
          7. Pour aller plus loin
       3. Conclusion
    5. Chapitre 10: Erlang et le développement Web
       1. Le serveur HTTP Inets
          1. Configuration et mise en œuvre
          2. Quelques modules d’extensions importants
          3. Le développement de modules Web Erlang
          4. Le développement de modules d’extension pour Inets
          5. Les limites d’Inets
       2. Développement d’applications Web avec Yaws
          1. Développement de scripts Yaws
          2. Le traitement des paramètres de requêtes
          3. Les réponses de la fonction out/1
          4. Les traitements réalisés dans un script Yaws
          5. Quel style de développement pour les fichiers Yaws?
          6. Développement d’une application Yaws
       3. Conclusion
    6. Chapitre 11: Serveurs et clients TCP/IP
       1. Client TCP/IP
          1. Réalisation d’un premier client TCP/IP
          2. Différents scénarii d’utilisation du client
       2. Serveur TCP/IP
          1. Définition du fonctionnement du serveur et du protocole
          2. Implémentation du serveur
          3. Mise en œuvre du serveur
          4. Limitations de notre premier serveur
       3. Application client-serveur : l’opération d’écho
          1. Définition du protocole
          2. Architecture du serveur
          3. Implémentation du serveur
          4. Première connexion à notre serveur
          5. Implémentation du client
       4. Réception des données réseaux sous forme de message Erlang
       5. Conclusion
11. Troisième Partie: Trois études de cas
    1. Chapitre 12: Créer un proxy d’annuaire LDAP
       1. Architecture de notre application
       2. Les grandes lignes de l’implémentation
          1. src/ldap_proxy_app.erl
          2. src/ldap_proxy_sup.erl
          3. src/ldap_connections_sup.erl
          4. src/ldap_accept_fsm.erl
          5. src/ldap_connection_srv.erl
       3. Le support du protocole ASN.1
          1. src/LDAPv3.asn
          2. La conversion du format ASN.1
       4. L’utilisation d’outils d’aide à la génération d’applications Erlang/OTP
          1. Utilisation de builder.erl
          2. Utilisation de l’outil Erlang make
          3. Génération de notre application
       5. La configuration de l’application OTP
          1. Les mécanismes de configuration d’une application OTP
          2. L’utilisation des paramètres de l’application dans le code
       6. Tracer les informations échangées entre le client et le serveur sur le proxy
          1. Une approche du développement par plug-in
          2. src/ldap_handler_file.erl
       7. L’utilisation des logs pour faciliter administration et débogage
       8. Le fonctionnement de l’application ldap_proxy
          1. Lancement et test de l’application
          2. Le suivi des logs applicatifs
       9. Conclusion
    2. Chapitre 13: Erlang et le jeu vidéo
       1. Jeu de la vie
          1. Les règles du jeu
          2. Implémentation du jeu de la vie en Erlang
          3. L’implémentation de la cellule
          4. L’implémentation du processus initialisant le jeu et transmettant les messages
          5. L’affichage de l’espace de jeu en mode console
          6. Lancement du jeu de la vie
          7. Exercice : variante dans les règles
          8. Envisager d’autres variantes
       2. Goonix-Rei : un jeu de rôle multi-joueur
          1. Pourquoi utiliser Erlang pour un développement de jeu vidéo?
          2. L’architecture de l’application
          3. Organisation des processus dans le code du serveur
          4. Le code des modules de comportement dans notre serveur
          5. Code de traitement protocolaire
          6. Le code des modules complémentaires
          7. Le code de packaging
          8. Le fonctionnement du jeu
       3. Conclusion
    3. Chapitre 14: Développement d’extensions pour le modeleur Wings 3D
       1. Les différents types d’extension
       2. Développer un plug-in d’analyse
          1. Initialisation du module
          2. Le premier événement reçu : {file, autosave}
          3. Le fonctionnement des menus
          4. La réception des événements
       3. Les différents types d’entrées de menu
          1. Les entrées de menu simples
          2. Les entrées de menu comportant une boîte de dialogue
          3. Les interrupteurs
          4. Les séparateurs de menu
       4. Le traitement des événements et l’analyse du monde 3D
          1. Représentation de l’événement
          2. La description du monde
       5. La réalisation de notre extension
       6. Conclusion
12. Index