Avant-got du

langage : une todo-list

distribue
Par bluestorm
et rks`

www.openclassrooms.com

2/9

Sommaire
Sommaire ........................................................................................................................................... 2
Avant-got du langage : une todo-list distribue ................................................................................ 3
Notes ................................................................................................................................................................................. 3
Le langage Erlang ............................................................................................................................................................. 3
Le problme du paralllisme ...................................................................................................................................................................................... 3
L'histoire d'Erlang ....................................................................................................................................................................................................... 4
Les concepts fondamentaux ...................................................................................................................................................................................... 4

Un exemple de programme ............................................................................................................................................... 4

Et le client ? ................................................................................................................................................................................................................ 7
Partager ....................................................................................................................................................................................................................... 7

www.openclassrooms.com

Sommaire

3/9

Avant-got du langage : une todo-list distribue

Par

bluestorm et

rks`

Mise jour : 01/01/1970

Ce tuto est un peu inhabituel car, au lieu de vous apprendre un langage de programmation, en partant des bases et en exposant
toutes ses caractristiques, il vise vous faire dcouvrir un langage. Il est donc conu pour tre court, et incomplet : c'est un
avant-got.
Aprs une prsentation succincte du langage et des problmatiques qu'il aborde, vous serez confronts un exemple de code,
qui met en valeur ses spcificits. Le but n'est pas d'apprendre la syntaxe, qui ne sera quasiment pas prsente (un minimum
quand mme, pour que vous puissiez lire le code
) mais plutt d'avoir un aperu des concepts du langage. C'est vous,
programmeurs, de faire le travail d'adaptation ; esprons que cela vous donnera peut-tre envie d'en savoir plus sur ce langage
surprenant !

Notes
Ce tuto a t rdig collaborativement ; inspir d'une news de Poulet, il a t rdig par Dark-Side et bluestorm.
Ce tuto a t crit, non pas en zCode, mais en mdown, un petit langage de mise en forme agrable utiliser (et qui peut produire
du zCode), conu par rz0; Vous pourrez trouver plus d'informations sur cette page.
Sommaire du tutoriel :

Le langage Erlang
Un exemple de programme

Le langage Erlang
Le problme du paralllisme
l'heure actuelle, les possibilits d'augmentation des performances des processeurs sont assez limites, et les fabricants ont
donc dcid de se tourner vers une mthode diffrente d'augmentation des performances : la multiplication des processeurs. Le
problme, c'est que les principaux programmes actuels sont crits pour tourner sur un seul processeur la fois, et souvent ne
savent donc pas exploiter cette possibilit.
Malheureusement, il est beaucoup plus difficile de concevoir des applications tournant sur plusieurs processeurs (ou threads,
ou plus gnralement "parties") en mme temps : la difficult rside principalement dans l'interaction entre les diffrentes parties
du programme. Si par exemple deux parties ont accs une mme variable, il y a un risque que l'une modifie cette variable
pendant que l'autre en avait besoin (imaginez qu'entre la vrification du mot de passe et son stockage (chiffr, videmment) dans
la BDD, une autre partie de votre site web modifie cette variable pour y stocker le contenu d'un message !). Pour viter ces
problmes on peut mettre en place un systme de "verrous", qui bloquent une variable en empchant la modification par les
autres parties. On rencontre alors des problmes encore plus complexes, o plusieurs parties se disputent le contrle des
variables dont elles ont besoin sans qu'aucune ne puisse avancer, jusqu' bloquer compltement tout le programme.
Ce n'est pas un problme li la comptence des programmeurs (on dit souvent par exemple que les problmes de scurit en
PHP sont en partie lis au niveau des webmasters) : mme pour un excellent programmeur, il est trs difficile, voir impossible, de
programmer une application concurrente (dont diffrentes parties s'excutent simultanment en interagissant) complexe sans
erreurs, et ces erreurs sont trs difficiles corriger. C'est un problme d'outils : les langages de programmation principaux ne sont
pas adapts.
Les programmeurs, et surtout les concepteurs de langages de programmation, se sont donc mis la recherche de manires

www.openclassrooms.com

Avant-got du langage : une todo-list distribue

4/9

diffrentes d'aborder le problme. Les ides qu'ils ont alors tent d'exploiter ne sont pour la plupart pas nouvelles, mais plutt
retrouves : elles viennent de langages moins utiliss par la majorit des programmeurs, conus par des "scientifiques",
principalement des universitaires, qui mettent en place des langages bass sur un support thorique solide, avec des approches
parfois radicalement diffrentes des langages "grand public".
Erlang, le langage que nous allons prsenter ici, est un de ces exemples de langages crs par une rencontre de la thorie
(programmation logique, et programmation fonctionnelle) et de la pratique (une quipe d'ingnieurs avec un problme prcis : la
tlcommunication).

L'histoire d'Erlang
Le langage Erlang est n du besoin d'un grand oprateur tlphonique, Ericsson, d'un langage adapt la programmation de
systmes complexes : certaines parties de l'infrastructure d'un oprateur grent en continu (24 heures sur 24, 7 jours sur 7, et une
panne est trs grave) un grand nombre de connexions simultanes.
Les recherches qui ont finalement donn naissance au langage Erlang ont commenc en 1981. Il s'agissait l'poque de versions
de Prolog, un langage de programmation logique, spcialises dans la programmation concurrente (on appelle concurrente la
programmation tenant compte de la communication et du partage des ressources entre diffrentes parties d'un programme qui
s'excutent en mme temps (ou dans un ordre indtermin)). Petit petit, les ingnieurs d'Ericsson ont fait natre un nouveau
langage, qui reprenait un grand nombre d'ides de Prolog, mais pas seulement (on observe par exemple une grande influence des
langages fonctionnels). Erlang est longtemps rest interne Ericsson, qui s'est mis ensuite le vendre des clients spcialiss.
En 1998, Ericsson a dcid de se recentrer sur l'utilisation de langages de programmation (Erlang tait alors devenu un des
points forts de l'entreprise, avec la mise en place de projets critiques dans ce langage), plutt que sur l'innovation en matire de
langages. L'quipe qui avait cr Erlang a donc quitt Ericsson, qui a alors dcid de rendre Erlang Open Source :
l'implmentation du langage, ainsi que les bibliothques l'accompagnant, ont t rendues disponibles tous.
Erlang est spcialis dans la concurrence, mais plus particulirement la gestion des erreurs : un programme Erlang peut
fonctionner dans un environnement trs htrogne (plusieurs machines connectes par une liaison peu fiable, par exemple), et
doit savoir grer les erreurs ou les problmes de communication. Tout est mis en place pour qu'un programme puisse surmonter
chaque erreur (au lieu de s'arrter tout simplement), et mme se rparer lui-mme : il est possible de modifier un programme Erlang
en direct, pendant son fonctionnement, sans que les utilisateurs observent de discontinuit.
Toutes ces qualits d'Erlang sont principalement dues un modle particulier de communication entre les diffrentes parties du
programme, par "envoi de message". C'est cette ide fondamentale que nous allons prsenter par la suite, avec une mise en
application.

Les concepts fondamentaux

Les processus
Un programme Erlang est constitu, pendant son excution, d'un ensemble de processus parallles (qui s'excutent en mme
temps, par exemple sur des processeurs diffrents). La communication entre ces processus s'effectue par transmission de
messages : chaque processus peut envoyer des messages un autre, qui peut les recevoir et effectuer des actions en
consquence.
Le nombre des processus et leurs relations dpendent du programme : on peut mettre en place une multitude de "schmas"
diffrents, avec par exemple un simple canal de communication (deux processus qui changent des messages), un modle clientserveur (un serveur central qui reoit des messages de tous les clients, qui ne communiquent pas directement entre eux), ou
mme une architecture pair pair (les clients se parlent entre eux). Le langage lui-mme n'impose aucun choix ce sujet, car la
mthode utilise (le passage de message) est trs flexible.

Communication asynchrone
Chaque processus envoie et reoit des messages. Il existe diffrents modles de messages, celui choisi par Erlang est
asynchrone : quand un processus A envoie un message un processus B, il ne "se passe rien" : le processus B n'est pas
perturb dans son fonctionnement.
Le message est en effet stock dans un espace spcifique au processus B, une sorte de "bote aux lettres", o il attend.
Priodiquement, le processus B peut consulter le contenu de sa bote aux lettres (plus il le fait souvent, plus vite il sera au
courant des messages qu'on lui envoie).
Cette mthode "dtendue" de communication, par sa grande souplesse, permet d'viter certains bugs lis aux problmes de
synchronisation.

www.openclassrooms.com

Avant-got du langage : une todo-list distribue

5/9

Un exemple de programme
titre d'exemple nous allons mettre en place une todo-list (liste de tches). Une todo-list se prsente comme une liste de tches
effectuer ("acheter des tomates", "prendre une douche", "manger"...), laquelle on peut ajouter des tches (quand le devoir
nous appelle) ou en retirer (quand on les a effectues).
Notre todo-list a la particularit d'tre multi-utilisateurs, c'est--dire qu'elle est accessible par plusieurs personnes 'en mme
temps' : tout le monde peut y ajouter ou en enlever des tches, ou consulter la liste.
On peut aussi imaginer des modles plus prcis (par exemple dans une cole : les professeurs ne font qu'ajouter des tches, et
vous, vous devez les retirer
), mais celui-l est suffisamment simple pour mettre en oeuvre la plupart des outils de base du
langage, tout en restant comprhensible.
Voici le code :
Code : Erlang
-module(todo_list).
-export([start/0, loop/1]).
loop(Liste) ->
receive
{add, X} -> loop([X|Liste]);
{del, X} -> loop([Y || Y <- Liste, Y =/= X]);
{From, show} -> From ! Liste,
loop(Liste);
close -> io:format("Fin de la connexion~n")
end.
start() ->
io:format("Cration d'un processus~n"),
spawn(todo_list, loop, [[]]).
Les deux premires lignes servent en fait dclarer notre programme. Par cette dnomination pour le moins surprenante, je veux
signifier que ces deux lignes vont nous permettre de rutiliser le code qui va tre crit ensuite.
Code : Erlang
-module(todo_list).
-export([start/0, loop/1]).
Ces deux directives ne sont pas intressantes pour une premire approche : elles s'occupent de la porte des variables et de
l'interaction de ce fichier avec le reste du code, un peu comme l'inclusion de .h en C, et les dclarations de porte (publique /
prive).
Comme cela a t expliqu dans la premire partie, de multiples schmas de communication sont possibles. Ici, nous allons mettre
en oeuvre une architecture client-serveur (simplifie). Plus exactement, ce code ne contient que le comportement du serveur
(fonction loop), c'est--dire la partie qui gre l'accs et la modification par tous les utilisateurs (les "clients") de la liste ; les
clients sont trs simples, et on peut passer directement par la console Erlang pour cela.
Le serveur fonctionne d'une manire assez spcifique aux programmes Erlang, que l'on peut dcrire de la manire suivante :
on donne la liste un "employ", on lui dit "garde-l tant que tu ne reois pas de message". S'il reoit un message, diffrents cas
se prsentent, selon le contenu du message ; on grera ici trois types de messages : "ajouter la tche machin", "retirer la tche
bidule", "montrer la liste la personne truc". Il agit en consquence, et la partie spcifique se droule ce moment-l : au lieu de
modifier la liste des tches, il donne une autre liste un nouvel employ, qui est alors charg de rpter le processus. Par
exemple, si le message tait "ajoute la tche 'manger'", il va donner un autre employ sa liste, ainsi que le message "manger" (ce
qui constitue donc une nouvelle liste plus grande), et c'est ce nouvel employ qui s'occupera des messages suivants.
C'est une mise en oeuvre particulire de la rcursivit, un concept dcrit dans un des tutos du SDZ.
Voyons maintenant le code. La structure receive .. end permet d'examiner les messages, et d'agir en fonction de leur
contenu. Si on prvoit de recevoir deux types de messages diffrents, le code aura cette tte-l (o expression dsigne un
bout de code qui renvoie une valeur) :
Code : Erlang

www.openclassrooms.com

Avant-got du langage : une todo-list distribue

6/9

receive
premier_type -> expression;
deuxieme_type -> expression
end
Code : Erlang
loop(Liste) ->
receive
{add, X} -> loop([X|Liste]);
{del, X} -> loop([Y || Y <- Liste, Y =/= X]);
{From, show} -> From ! Liste,
loop(Liste);
close -> io:format("Fin de la connexion~n")
end.
On peut remarquer que le point-virgule (;) ne sert pas sparer les instructions, mais sparer les diffrents cas possibles. Pour
excuter deux instructions la suite, on utilise une simple virgule.
Ici, on reoit quatre types de messages :
l'ajout d'un lment une liste ;
la suppression d'un lment de la liste ;
la demande d'affichage de la liste quelqu'un ;
un message de fin, en cas de fermeture de l'application.
Le message de fermeture est "simple" : c'est le message close : quand on le reoit, on envoie un message de fermeture, et on
s'arrte. Les autres messages sont un peu plus dlicats parce qu'ils contiennent de l'information : quand on envoie le message
"ajoute la liste", il faut prciser l'lment ajouter : il est contenu dans le message. De mme, le message "montre la liste
machin" doit contenir l'adresse de machin, pour que le serveur puisse lui envoyer la liste. Pour faire cela, on utilise des messages
en plusieurs parties : {..., ...} est un message en deux parties. Certaines parties sont fixes (par exemple add et del) : on
appelle a des atomes, et on peut voir cela un peu comme des constantes dfinies par le programmeur. D'autres parties sont
variables : le X dans les deux premiers messages est une variable qui contient la valeur donne (et dpend donc du message
reu). Les parties fixes sont en minuscules, et les parties variables commencent par une majuscule.
Le message d'ajout fonctionne simplement : si l'on reoit {add, X} (on sait que c'est un message d'ajout grce la prsence de
l'atome add), on rappelle loop avec la nouvelle valeur [X|Liste], c'est--dire une liste qui contient tous les lments de la
liste initiale, plus le contenu de la variable X. (c'est l qu'on doit imaginer que l'on donne cette nouvelle liste un nouvel
employ).
La nouvelle liste donne en cas de message de suppression est un peu particulire : la syntaxe [Y || Y <Liste, truc(Y)] signifie "tous les lments Y de la liste, qui vrifient 'truc'". Ici, on slectionne tous les lments de la
liste qui sont diffrents de X : la fin, on a donc la liste, sauf la valeur de X, qui a donc bien t supprime. C'est ce qu'on appelle
une comprhension de liste (expression maladroite venant de l'anglais "list comprehension").
Enfin, le message "montrer la liste machin" met en oeuvre une deuxime structure essentielle la communication interprocessus en Erlang, l'envoi de messages : !. La syntaxe est Pid ! Msg, et cela envoie le message Msg au processus dont
l'adresse est Pid. Ici, cette adresse a t donne dans le message, c'est la valeur From (vous pouvez remarquer que
contrairement aux deux premiers messages, la partie variable a t place en premier : c'est la convention quand on envoie son
adresse dans un message). La valeur que l'on envoie est Liste : on envoie bien le contenu de la liste de tches au processus
dont l'adresse est From. Ensuite (aprs la virgule) on rappelle loop(Liste) : le serveur continue tourner, avec la mme liste.
Voici enfin la dernire fonction du programme, qui joue un peu le rle du "main" en C : c'est la fonction de dpart, qui est appele
au lancement du programme.
Code : Erlang
start() ->
io:format("Cration d'un processus~n"),
spawn(todo_list, loop, [[]]).
La fonction start contient deux instructions spares par une virgule (Erlang utilise le point-virgule pour dnoter un autre
type de sparation, c'est donc la virgule que l'on utilise pour sparer deux instructions ; les fonctions sont spares par des

www.openclassrooms.com

Avant-got du langage : une todo-list distribue

7/9

points). La premire instruction, io:format, affiche du texte sur la sortie standard.

La deuxime instruction est plus intressante : ll s'agit de la dernire des trois structures principales de gestion de la concurrence
en Erlang : c'est la fonction spawn, qui lance un nouveau processus, et renvoie un identifiant le concernant.
Les arguments contiennent le module utiliser (ici todo_list), le nom de la fonction appeler (loop), et enfin une liste
d'arguments donner cette fonction : avec [[]], on donne un seul argument qui est [], la liste vide : au dpart, notre todolist sera vide.

Et le client ?
Le client ne prsente que peu d'intrt : il suffit d'envoyer au serveur les bons messages, et cela marche tout seul.
Pour une mise en oeuvre rapide de cette todo-list, on peut utiliser la console Erlang. C'est un environnement interactif (un peu
comme la ligne de commande sous GNU/Linux) qui permet de manipuler des modules Erlang de manire simple, pour faire des
tests par exemple.
Le rsultat se prsente ainsi : les lignes qui commencent par un nombre suivi de > sont les lignes de code que l'utilisateur a
entres. Les lignes qui les suivent sont les rsultats renvoys par la console. Ici, l'utilisateur manipule notre module
todo_list, en envoyant une tche au serveur, avant de rcuprer la liste des tches. Les phrases aprs %% sont des
commentaires : elle servent d'explications mais ne sont pas lues par l'interprteur.
Code : Erlang
1> c(todo_list). %% cette commande sert compiler le module
{ok,todo_list}
2> Serv = todo_list:start(). %% on initialise la variable Serv avec
le pid (l'adresse)
Creation d'un processus
%% du processus cr dans start (le
serveur)
<0.38.0>
3> Serv ! {add, "faire mes devoirs"}. %% on ajoute un lment
notre todo-list
{add,"faire mes devoirs"}
4> Serv ! {self(), show}. %% self() permet d'obtenir le pid du
processus courant,
{show, <0.31.0>}
%% ncessaire pour que le serveur puisse
rpondre
5> receive Liste -> Liste end. %% reoit la rponse du serveur et
on l'affiche
["faire mes devoirs"]
6> Serv ! close. %% on ferme la connexion
Fin de la connexion
close
7>
Voil une brve prsentation du langage. J'espre que vous comprenez peu prs comment fonctionne la communication entre
processus.
Certains se demanderont peut-tre ce qu'apporte Erlang par rapport un langage gnraliste comme le C dans ce cas prcis.
L'exemple est peut-tre un peu trop simple pour exposer vritablement les avantages de cette mthode, mais on peut dj
constater que cette todo-list est potentiellement accessible de n'importe o (mme travers le rseau, si on met en place le client
Erlang correspondant), et ce sans surcot, alors que l'ajout de cette fonctionnalit demanderait dans un autre langage un effort
important. C'est l la grande force de l'Erlang.
Quoi qu'il en soit, nous esprons vous avoir donn envie de dcouvrir un peu plus profondment l'Erlang. Une simple prconnaissance de la diversit des langages de programmation vous servira srement, mme si vous ne vous lancez pas
immdiatement dans un nouveau langage, mais si par hasard c'tait votre souhait, vous pouvez aller consulter le site web ddi
au langage.
Si vous voulez directement un cours complet, et que lire en anglais ne vous gne pas (trop), vous pouvez essayer ce livre (en
ligne).

Partager
www.openclassrooms.com

Avant-got du langage : une todo-list distribue

Ce tutoriel a t corrig par les zCorrecteurs.

www.openclassrooms.com

8/9