Mon apprentissage de Erlang

[Sephi-Chan]

Hello,

En cette fin d'année et à l'approche de trois semaines de vacances, j'ai décidé d'apprendre le langage Erlang. En effet, j'ai dans l'idée de réaliser des daemon pour exposer des services aux créateurs de jeux et ce langage s'y prête plutôt bien.

Comme c'est toujours intéressant de découvrir de nouveaux langages, je compte vous faire part de ce que je découvre : des bouts de code, ce qui me plaît, ce qui ne me plaît pas, etc.

Pour m'aider, je dispose du livre Programming Erlang: Software for a Concurrent World de Joe Armstrong.

Tout d'abord, quelques mots pour décrire Erlang : c'est un langage de programmation fonctionnelle créé par Ericsson pour développer des systèmes concurrents qui tourne très longtemps (on peut mettre à jour le code sans arrêter le système), distribués (répartis sur plusieurs machines), fault-tolerant (tolère des pannes matérielles). Il est multi-plateforme et repose sur une machine virtuelle.

De nombreux gros logiciels reposent dessus : CouchDB, Riak, RabbitMQ, Membase, SimpleDB, ejabberd (qui propulse notamment le chat de Facebook), etc.

Voilà, voilà, plus qu'à découvrir.

[Sephi-Chan]

Après l'avoir installé (avec Homebrew), j'ai lancé la console Erlang pour tester un peu le langage.

Le premier choc : les lignes doivent être terminées par un point.
Second choc : les variables d'Erlang (qui commencent toujours par une majuscule) sont des variables au sens mathématique du terme et on ne peut pas changer leur valeur une fois affectée. On utilise l'opérateur = qui est une affectation, mais pas seulement (le suspens est à son combe)…

1> A = 5.

5

2> B = 9.

9

3> A = 6.

** exception error: no match of right hand side value 6

4> A = B.

** exception error: no match of right hand side value 9

5> A = 

Ce mécanisme qui paraît très contraignant empêche d'avoir un programme a état mutable : une case mémoire est associée à une valeur et c'est tout. Ainsi, dans le cas d'un accès concurrent à une même variable, on sait toujours à quoi s'attendre et il n'y a pas de mécanisme de lock qui ralentissent : ça permet au langage d'être temps-réel. Ça facilite grandement la parallélisation des programmes.


Ensuite, j'ai rencontré une autre notion à laquelle j'étais déjà habitué en Ruby (avec les symboles) : les atoms. Ils représentent des valeurs constantes et non numériques. Les atomes sont de simples mots (qui commencent par une minuscules). En interne, ils sont associés à des nombres (et ont donc une occupation mémoire très faible). En tant que tel, ils ne servent à rien. On les utilise pour mettre en place le pattern matching et pour donner un contexte au tulples.


Les tuples sont des structures au contenu arbitraire :

1> Point = { 12, 66 }.

{12,66}

2> Person = { person, { name, "Romain" }, { age, 22 } }.

{person,{name,"Romain"},{age,22}}

Ici, person, name et age sont des atoms.

On peut extraire des valeurs d'un tuple en faisant du pattern matching : on fait correspondre un motif à une valeur (ou une variable contenant cette valeur). On utilise à nouveau l'opérateur = pour faire ça.

1> { X, Y } = Point.

{12,66}

3> X.

12

4> Y.

66

5> { Type, { _, Name }, { _, Age } } = Person

{person,{name,"Romain"},{age,22}}

6> Type.

person

7> Name.

"Romain"

8> Age.

22

La suite une autre fois.

[ToraTora]

Excellent !
Merci Sephi de nous faire partager ta découverte avec nous

Je n'ai jamais travaillé avec des variables non-variables, mais ça doit être intéressant.

[Sephi-Chan]

Les listes sont une suite d'éléments (pas forcément d'un même type). On peut leur appliquer le pattern matching pour en extraire des éléments. Le | sert à distinguer la tête (head) de la queue (tail).

1> Letters = [ a, b, c, d ].

[a,b,c,d]

2> [ A | Others ] = Letters.

[a,b,c,d]

3> A.

a

4> Others.

[b,c,d]

5> [ A, B | Rest ] = Letters.

[a,b,c,d]

6> A.

a

7> B.

b

8> Rest.

[c,d]

Les chaînes de caractères ne sont pas une force d'Erlang. De base, elles sont strictement équivalente à une liste de nombres. Les nombres sont les identifiants de ces caractères au sein du jeu de caractère ISO-8859-1 (aussi appelé Latin-1).

Ainsi, si on déclare une liste composée uniquement de nombres qui sont présents dans la table de caractères, Erlang nous affiche la chaîne équivalente. Et du coup elles sont strictement équivalentes.

1> [ 74, 101, 117, 87, 101, 98 ].

"JeuWeb"

2> JeuWebAsNumbers = [ 74, 101, 117, 87, 101, 98 ].

"JeuWeb"

3> JeuWebAsString = "JeuWeb".

"JeuWeb"

4> JeuWebAsString = JeuWebAsNumbers.

"JeuWeb"

L'affectation de la ligne 4 ne produit pas d'erreur ! C'est donc que les 2 notations sont bien équivalentes !

On peut encore utiliser le pattern matching pour extraire des valeurs.

1> [ J, _, _, W | _ ] = JeuWeb.      

"JeuWeb"

2> J.

74

3> W.

87

4> [ J, _, _, W | Rest ] = JeuWeb.

"JeuWeb"

5> Rest.

"eb"

[popayan]

Intéressant tout ca!

[mode chieur] mais t'avais pas de screencast à faire???[/mode]

[Sephi-Chan]

Si, mais comme je vais partir en vacances pendant 3 semaines et que je ne compte pas emmener le micro, j'ai trouvé un autre de faire travailler mon petit cerveau pendant les temps morts !

Ce soir, mon rapport sur les modules et les list comprehensions ! Stay tuned !

[Akira777]

Très intéressant tout ça, je n'avais vu à quoi pouvais ressembler ce langage. Merci du partage Sephi-chan !

[Sephi-Chan]

Les modules permettent de regrouper les fonctions.
Voici un exemple de module, défini dans un fichier nommé geometry.erl (c'est important) :

-module(geometry).

-export([ area/1 ]).



area({ rectangle, Width, Height }) -> Width * Height;

area({ circle, Radius })           -> 3.14 * Radius * Radius.

On définit un module geometry et on expose une fonction nommée "area" et d'arité 1 (elle accepte 1 argument).

On peut ensuite voir 2 définitions. C'est encore du pattern matching : la fonction area regardera la "tronche" de son argument et le comparera aux différents pattern qu'elle comprend, dans l'ordre dans lequel apparaissent les patterns dans le code. Si on passe un argument qui ne correspond à aucun motif, Erlang criera très fort.

Ici, on distingue 2 motifs. Les deux sont des tuples (mais ça pourrait être autre chose) à laquelle la fonction peu apporter 2 réponses bien différentes.

Pour essayer ce module, on lance à nouveau une console (depuis l'endroit où se trouve votre fichier geometry.erl, sinon il faudra faire un cd("/Users/romaintribes/Development/Erlang") depuis la console Erlang) et on compile le module.

1> c(geometry).

{ok,geometry}

2> geometry:area({ rectangle, 10, 15 }).

150

3> geometry:area({ circle, 5 }).

78.5

4> geometry:area({ circle, 5, 5 }).

** exception error: no function clause matching geometry:area({circle,5,5})

La compilation du module a crée un fichier geometry.beam. Tant que ce fichier existe, vous pourrez accéder au module geometry, sans avoir à le recompiler à chaque fois que vous ouvrez la console.

On peut voir que le pattern matching marche bien et que mine de rien, le code est plutôt concis.

[ToraTora]

La première définition finit par un ; ?

[Sephi-Chan]

Oui, car une autre possibilité de pattern suit.
Seul la dernière instruction s'achève par un point.