Programmer en Erlang Francesco Cesarini et Simon ... - Pearson

Programmer
en Erlang
Francesco Cesarini et Simon Thompson
Traduit par Éric Jacoboni,
avec la contribution technique de Samuel Tardieu
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson

Pearson Education France a apporté le plus grand soin à la réalisation de ce livre afin de vous
fournir une information complète et fiable. Cependant, Pearson Education France n’assume de
responsabilités, ni pour son utilisation, ni pour les contrefaçons de brevets ou atteintes aux droits
de tierces personnes qui pourraient résulter de cette utilisation.
Les exemples ou les programmes présents dans cet ouvrage sont fournis pour illustrer les
descriptions théoriques. Ils ne sont en aucun cas destinés à une utilisation commerciale ou
professionnelle.
Pearson Education France ne pourra en aucun cas être tenu pour responsable des préjudices
ou dommages de quelque nature que ce soit pouvant résulter de l’utilisation de ces exemples ou
programmes.
Tous les noms de produits ou marques cités dans ce livre sont des marques déposées par leurs
propriétaires respectifs.
Publié par Pearson Education France
47 bis, rue des Vinaigriers
75010 PARIS
Tél. : 01 72 74 90 00
www.pearson.fr
Mise en pages : TyPAO
ISBN : 978-2-7440-2445-0
Copyright © 2010 Pearson Education France
Tous droits réservés
Titre original : Erlang
Traduction : Éric Jacoboni, avec la contribution
technique de Samuel Tardieu
ISBN original : 978-0-596-51818-9
Copyright © 2009 by Francesco and
Simon Thompson
Tous droits réservés
Published by O’Reilly Media, Inc.
1005 Gravenstein Highway North,
Sebastopol, CA 95472
Aucune représentation ou reproduction, même partielle, autre que celles prévues à l’article L. 122-5 2˚ et 3˚ a) du code de
la propriété intellectuelle ne peut être faite sans l’autorisation expresse de Pearson Education France ou, le cas échéant,
sans le respect des modalités prévues à l’article L. 122-10 dudit code.
All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or
mechanical, including photocopying, recording or by any information storage retrieval system, without permission from
Pearson Education, Inc.
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson

Table des matières
Avant-propos.................................................................................................................................... XVII
À propos des auteurs......................................................................................................................
XIX
Préface................................................................................................................................................ 1
Pourquoi Erlang ................................................................................................................... 1
Public visé .............................................................................................................................. 2
Structure de l'ouvrage............................................................................................................ 3
Conventions typographiques ............................................................................................... 4
Remerciements....................................................................................................................... 5
1 Introduction............................................................................................................................ 7
Pourquoi utiliser Erlang .................................................................................................... 7
Historique................................................................................................................................ 9
Caractéristiques d'Erlang ..................................................................................................... 10
Constructions de haut niveau ...................................................................................... 10
Processus concurrents et envoi de messages .......................................................... 11
Concurrence supportant la montée en charge, sûre et efficace .......................... 12
Temps réel souple........................................................................................................... 13
Robustesse........................................................................................................................ 13
Informatique distribuée ................................................................................................ 14
Intégration et ouverture................................................................................................. 15
Erlang et les processeurs multicœurs.................................................................................. 16
Études de cas........................................................................................................................... 17
Le commutateur ATM AXD301................................................................................. 17
CouchDB.......................................................................................................................... 18
Comparaison d'Erlang et de C++............................................................................... 19
Comment utiliser Erlang ................................................................................................... 21
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson

IV Programmer en Erlang
2 Bases d’Erlang....................................................................................................................... 23
Entiers .................................................................................................................................. 23
Le shell Erlang........................................................................................................................ 24
Flottants .................................................................................................................................. 25
Opérateurs mathématiques........................................................................................... 25
Atomes .................................................................................................................................. 27
Booléens.................................................................................................................................. 28
Tuples .................................................................................................................................. 30
Listes .................................................................................................................................. 31
Caractères et chaînes..................................................................................................... 31
Atomes et chaînes........................................................................................................... 32
Construction et traitement des listes.......................................................................... 33
Fonctions et opérations sur les listes......................................................................... 34
Comparaisons de termes....................................................................................................... 37
Variables.................................................................................................................................. 39
Types de données composés ................................................................................................ 41
Pattern Matching.................................................................................................................... 43
Fonctions................................................................................................................................. 47
Modules .................................................................................................................................. 50
Compilation et machine virtuelle Erlang.................................................................. 51
Directives des modules................................................................................................. 51
Exercices ................................................................................................................................. 53
3 Programmation séquentielle en Erlang........................................................................... 57
Évaluations conditionnelles.................................................................................................. 58
La structure case ............................................................................................................ 58
Portée des variables ...................................................................................................... 61
La structure if ................................................................................................................. 62
Gardes .................................................................................................................................. 63
Fonctions prédéfinies............................................................................................................. 65
Accès et examen des objets ........................................................................................ 66
Conversion de type ........................................................................................................ 67
Traitement des dictionnaires ....................................................................................... 68
Métaprogrammation...................................................................................................... 68
Processus, port, distribution et informations système........................................... 69
Entrées/sorties................................................................................................................. 69
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson

Table des matières V
Récursivité............................................................................................................................... 72
Fonctions récursives terminales ................................................................................. 77
Optimisation des appels récursifs terminaux ......................................................... 80
Itérations vs. fonctions récursives............................................................................... 81
Erreurs d'exécution ............................................................................................................... 82
Traitement des erreurs........................................................................................................... 84
Utilisation de try ... catch............................................................................................. 84
Utilisation de catch........................................................................................................ 88
Modules de la bibliothèque ................................................................................................. 91
Documentation................................................................................................................ 91
Modules utiles................................................................................................................. 93
Le débogueur ......................................................................................................................... 94
Exercices ................................................................................................................................. 96
4 Programmation concurrente.............................................................................................. 103
Création des processus.......................................................................................................... 104
Envoi de messages................................................................................................................. 106
Réception des messages........................................................................................................ 109
Réceptions sélectives et non sélectives .................................................................... 112
Un exemple d'écho......................................................................................................... 114
Processus enregistrés............................................................................................................. 116
Délais d'expiration................................................................................................................. 119
Tests de performances........................................................................................................... 121
Squelettes de processus......................................................................................................... 122
Récursion terminale et fuites mémoire .............................................................................. 123
Étude de cas de programmation concurrente ................................................................... 124
Race conditions, interblocages et famine des processus................................................. 127
Le gestionnaire de processus................................................................................................ 128
Exercices ................................................................................................................................. 130
5 Patrons de conception des processus................................................................................ 133
Modèles client/serveur.......................................................................................................... 134
Exemple de client/serveur............................................................................................ 135
Exemple de patron processus .............................................................................................. 141
Machines à états finis ........................................................................................................... 143
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson

VI Programmer en Erlang
Exemple de FSM............................................................................................................ 143
Sémaphore mutex........................................................................................................... 145
Gestionnaires d'événements et traitements d'événements............................................... 147
Exemple de gestionnaire d'événements générique ................................................ 149
Traitements d'événements ........................................................................................... 152
Exercices ................................................................................................................................. 154
6 Traitement des erreurs des processus.............................................................................. 157
Liens entre processus et signaux exit ................................................................................. 157
Blocage des exit.............................................................................................................. 160
La BIF monitor............................................................................................................... 162
Les BIF exit...................................................................................................................... 163
BIF et terminologie ....................................................................................................... 164
Sémantique de la propagation..................................................................................... 166
Systèmes robustes.................................................................................................................. 167
Surveillance des clients................................................................................................. 168
Exemple de superviseur................................................................................................ 170
Exercices ................................................................................................................................. 173
7 Enregistrements et macros................................................................................................. 175
Enregistrements...................................................................................................................... 176
Introduction aux enregistrements............................................................................... 176
Utilisation des enregistrements .................................................................................. 177
Fonctions et pattern matching sur les enregistrements......................................... 178
Manipulation d'enregistrements dans le shell.......................................................... 179
Implémentation des enregistrements......................................................................... 181
BIF pour les enregistrements ...................................................................................... 183
Macros .................................................................................................................................. 183
Macros simples .............................................................................................................. 183
Macros paramétrées....................................................................................................... 184
Débogage et macros....................................................................................................... 185
Fichiers inclus................................................................................................................. 187
Exercices ................................................................................................................................. 187
8 Mises à jour logicielles......................................................................................................... 191
Mise à jour des modules....................................................................................................... 191
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson

Table des matières VII
En coulisse............................................................................................................................... 194
Chargement du code...................................................................................................... 197
Le serveur de code......................................................................................................... 198
Mise à jour des processus .................................................................................................... 201
Le fichier .erlang.................................................................................................................... 205
Exercice .................................................................................................................................. 205
9 Autres types de données et constructions de haut niveau.......................................... 207
Programmation fonctionnelle en pratique.......................................................................... 207
Funs et fonctions du premier ordre .................................................................................... 208
Fonctions en paramètres............................................................................................... 209
Fun expressions ............................................................................................................. 210
Fonctions comme résultats........................................................................................... 211
Utilisation de fonctions déjà définies ....................................................................... 213
Fonctions et variables.................................................................................................... 213
Fonctions du premier ordre prédéfinies ................................................................... 214
Évaluation paresseuse et listes.................................................................................... 215
Listes en intension.................................................................................................................. 216
Premier exemple ............................................................................................................ 216
Syntaxe des listes en intension.................................................................................... 217
Générateurs multiples.................................................................................................... 218
Fonctions standard......................................................................................................... 219
Binaires et sérialisation......................................................................................................... 220
Binaires ............................................................................................................................ 220
La syntaxe bit.................................................................................................................. 222
Pattern matching sur les bits........................................................................................ 224
Bitstring en intension..................................................................................................... 225
Exemple de syntaxe bit : décodage de segments TCP.......................................... 225
Opérateurs bit à bit......................................................................................................... 227
Sérialisation..................................................................................................................... 228
Références............................................................................................................................... 229
Exercices ................................................................................................................................. 230
10 Tables ETS et Dets................................................................................................................ 233
Tables ETS.............................................................................................................................. 233
Implémentations et compromis................................................................................... 234
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson

VIII Programmer en Erlang
Création de tables........................................................................................................... 236
Traitement des éléments d'une table.......................................................................... 238
Exemple : construction d'un index, acte I................................................................. 238
Parcours des tables......................................................................................................... 241
Exemple : construction d'un index, acte II............................................................... 242
Extraction d'informations : match.............................................................................. 243
Extraction d'informations : select............................................................................... 245
Autres opérations sur les tables.................................................................................. 247
Enregistrements et tables ETS.................................................................................... 247
Visualisation des tables................................................................................................. 248
Tables Dets.............................................................................................................................. 249
Exemple de base de données d'abonnés mobiles ............................................................. 252
Opérations du backend.................................................................................................. 253
Le serveur de base de données.................................................................................... 259
Exercices.................................................................................................................................. 264
11 Programmation distribuée en Erlang.............................................................................. 267
Systèmes distribués en Erlang.............................................................................................. 267
Informatique distribuée en Erlang : les bases.................................................................... 270
Noms des nœuds et visibilité....................................................................................... 271
Communication et sécurité.......................................................................................... 272
Communication et messages....................................................................................... 274
Connexions des nœuds.................................................................................................. 275
Appels de procédures distantes................................................................................... 278
Le module rpc.................................................................................................................. 280
Modules principaux pour la programmation distribuée ...................................... 281
Le processus epmd................................................................................................................. 282
Erlang distribué et pare-feux ...................................................................................... 283
Exercices ................................................................................................................................. 284
12 Comportements OTP........................................................................................................... 285
Introduction aux comportements OTP................................................................................ 285
Serveurs génériques............................................................................................................... 288
Lancement du serveur................................................................................................... 288
Envoi de messages.......................................................................................................... 290
Arrêt du serveur ............................................................................................................. 292
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson

Table des matières IX
L'exemple complet ........................................................................................................ 293
Exécution de gen_server............................................................................................... 296
Superviseurs............................................................................................................................ 299
Spécifications des superviseurs................................................................................... 300
Spécifications des fils ................................................................................................... 300
Exemple de superviseur................................................................................................ 301
Fils dynamiques.............................................................................................................. 302
Applications............................................................................................................................ 303
Structure des répertoires............................................................................................... 304
Fichiers de ressource des applications ..................................................................... 305
Démarrage et arrêt des applications........................................................................... 307
Le moniteur d'applications........................................................................................... 310
Gestion de la publication...................................................................................................... 311
Autres comportements et lectures complémentaires........................................................ 313
Exercices ................................................................................................................................. 314
13 Présentation de Mnesia........................................................................................................ 317
Utilisation de Mnesia............................................................................................................. 317
Configuration de Mnesia....................................................................................................... 319
Création du schéma ....................................................................................................... 319
Lancement de Mnesia.................................................................................................... 320
Tables de Mnesia............................................................................................................ 321
Transactions............................................................................................................................ 323
Écriture ............................................................................................................................ 324
Lecture et suppressions ................................................................................................ 325
Indexation......................................................................................................................... 326
Dirty operations ............................................................................................................. 328
Réseaux partitionnés.............................................................................................................. 330
Pour aller plus loin... ............................................................................................................ 330
Exercices ................................................................................................................................. 331
14 Programmation d’interfaces graphiques avec wxErlang........................................... 333
wxWidgets............................................................................................................................... 333
wxErlang : un binding Erlang pour wxWidgets................................................................ 335
Objets et types................................................................................................................. 335
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson

X Programmer en Erlang
Traitement des événements, identifiants d'objets et types d'événements ......... 336
Récapitulatif .................................................................................................................... 338
Premier exemple : MicroBlog.............................................................................................. 338
Second exemple : MiniBlog................................................................................................. 341
Installation et exécution de wxErlang................................................................................. 345
Exercices.................................................................................................................................. 345
15 Programmation des sockets................................................................................................ 347
UDP : User Datagram Protocol.......................................................................................... 347
TCP : Transmission Control Protocol................................................................................ 351
Exemple TCP................................................................................................................... 353
Le module inet........................................................................................................................ 356
Pour aller plus loin................................................................................................................. 357
Exercices ................................................................................................................................. 358
16 Lier Erlang avec d’autres langages de programmation............................................. 361
Présentation du problème .................................................................................................... 362
Interagir avec Java.................................................................................................................. 363
Nœuds et boîtes aux lettres ......................................................................................... 363
Représentation des types Erlang................................................................................. 364
Communication............................................................................................................... 364
Récapitulatif : RPC revisité......................................................................................... 365
Interactions....................................................................................................................... 366
Notes de bas de page..................................................................................................... 367
Pour aller plus loin......................................................................................................... 368
Nœuds C.................................................................................................................................. 368
Pour aller plus loin......................................................................................................... 372
Erlang à partir du shell Unix : erl_call............................................................................... 372
Programmes ports.................................................................................................................. 373
Commandes Erlang pour les ports ............................................................................ 374
Communication des données vers ou à partir d'un port ....................................... 376
Bibliothèques de communication........................................................................................ 377
Programmer en Ruby : erlectricity............................................................................. 377
Pilotes liés et FFI.................................................................................................................... 379
Exercices ................................................................................................................................. 379
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson

Table des matières XI
17 BIF de traces, dbg et spécifications de capture ............................................................ 381
Introduction............................................................................................................................. 381
Les BIF de trace..................................................................................................................... 383
Options de trace des processus.................................................................................... 384
Héritage des options...................................................................................................... 387
Ramasse-miettes et étiquettes temporelles ............................................................. 388
Trace des appels avec la BIF trace_pattern....................................................................... 389
L'outil dbg............................................................................................................................... 392
Présentation de dbg........................................................................................................ 393
Fonctions de trace et de profilage............................................................................... 395
Trace des appels de fonctions locaux et globaux .................................................. 396
Environnements distribués........................................................................................... 398
Redirection des sorties.................................................................................................. 398
Spécifications de capture : syntaxe fun.............................................................................. 401
Production de spécifications avec fun2ms............................................................... 402
Différences entre les spécifications de capture ets et dbg.................................... 410
Spécifications de capture en détail ..................................................................................... 410
Tête ............................................................................................................................ 410
Conditions........................................................................................................................ 412
Corps ............................................................................................................................ 415
Sauvegarde des spécifications de capture ................................................................ 418
Pour aller plus loin ................................................................................................................ 419
Exercices ................................................................................................................................. 420
18 Types et documentation....................................................................................................... 423
Types en Erlang...................................................................................................................... 423
Exemple : enregistrements avec champs typés ...................................................... 423
Notation des types Erlang............................................................................................ 424
TypEr : types succès et inférence de types ....................................................................... 426
Dialyzer : DIscrepancy AnaLYZer for ERlang programs.................................... 429
Documentation avec EDoc................................................................................................... 430
Documentation de bd_abos.erl................................................................................... 431
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson

XII Programmer en Erlang
Lancement d'EDoc......................................................................................................... 433
Types dans EDoc............................................................................................................ 436
Aller plus loin avec EDoc............................................................................................ 437
Exercices.................................................................................................................................. 438
19 EUnit et développement guidé par les tests.................................................................... 439
Développement guidé par les tests...................................................................................... 439
EUnit .................................................................................................................................. 440
Utilisation d'EUnit.......................................................................................................... 441
Exemple de test fonctionnel : sérialisation d'un arbre .......................................... 442
Infrastructure d'EUnit............................................................................................................ 445
Macro d'assertions.......................................................................................................... 445
Générateurs de tests....................................................................................................... 445
Représentation de tests EUnit..................................................................................... 446
Test des systèmes à états....................................................................................................... 447
Fixtures : initialisation et nettoyage .......................................................................... 447
Test des programmes concurrents....................................................................................... 448
Exercices ................................................................................................................................. 449
20 Style et efficacité.................................................................................................................... 451
Applications et modules........................................................................................................ 451
Bibliothèques................................................................................................................... 452
Code sale........................................................................................................................... 453
Interfaces.......................................................................................................................... 453
Valeurs des résultats ...................................................................................................... 454
Structures de données internes.................................................................................... 456
Processus et concurrence...................................................................................................... 456
Conventions de style.............................................................................................................. 461
Stratégies de codage.............................................................................................................. 467
Efficacité.................................................................................................................................. 469
Programmation séquentielle........................................................................................ 469
Listes ............................................................................................................................ 470
Récursivité terminale et non terminale .................................................................... 472
Concurrence..................................................................................................................... 472
Enfin... ................................................................................................................................. 474
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson

Table des matières XIII
Annexe. Utilisation d’Erlang........................................................................................................ 477
Débuter avec Erlang ............................................................................................................. 477
Installation du système.................................................................................................. 477
Utilisation du shell Erlang............................................................................................ 477
Outils pour Erlang.................................................................................................................. 479
Éditeurs ............................................................................................................................ 479
Autres outils..................................................................................................................... 480
Pour aller plus loin ................................................................................................................ 481
Index................................................................................................................................................... 483
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson