Академический Документы
Профессиональный Документы
Культура Документы
Faciltad de Ingenier
a
Teor
a del Lenguaje
Erlang
Mirian Quinteros
Luis Arancibia
Patricia Dimasi
1er cuatrimestre
29 de junio de 2013
Erlang
INDICE
Indice
1. Introduccion 3
1.1. Filosofa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.1.1. Let it crash . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2. Historia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.1. Prehistoria . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.2. Primeros pasos a Erlang . . . . . . . . . . . . . . . . . . . 8
1.3. Sistemas reales que usan Erlang . . . . . . . . . . . . . . . . . . . 9
2. Estructura y sintaxis del lenguaje 9
2.1. Consola o Shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2. Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3. Atoms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.4.
Algebra Booleana y operadores de comparacion . . . . . . . . . . 11
2.5. Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.5.1. Tipos numericos . . . . . . . . . . . . . . . . . . . . . . . 13
2.5.2. Tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.5.3. Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.5.4. Listas de comprension . . . . . . . . . . . . . . . . . . . . 16
2.5.5. Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.5.6. Otros tipos . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.5.7. Bit Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.5.8. Comprension de binarios . . . . . . . . . . . . . . . . . . . 20
2.5.9. Representacion interna . . . . . . . . . . . . . . . . . . . . 21
2.6. Modulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.7. Estructuras de control . . . . . . . . . . . . . . . . . . . . . . . . 22
2.7.1. Pattern Matching . . . . . . . . . . . . . . . . . . . . . . . 22
2.7.2. Guards . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.7.3. If y Case . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.7.4. Conversion de tipos . . . . . . . . . . . . . . . . . . . . . 24
2.8. Recurrencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.8.1. Tail Recursion . . . . . . . . . . . . . . . . . . . . . . . . 25
2.9. Funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.9.1. Funciones de alto orden . . . . . . . . . . . . . . . . . . . 27
3. Aspectos de orientacion a Objetos y TADs 27
4. La maquina virtual de Erlang 28
5. Recolector de basura 28
6. Concurrencia 29
6.1. Concurrencia en Erlang . . . . . . . . . . . . . . . . . . . . . . . 29
6.2. Manejo de procesos . . . . . . . . . . . . . . . . . . . . . . . . . . 29
6.2.1. Cliente-Servidor . . . . . . . . . . . . . . . . . . . . . . . 31
1
Erlang
INDICE
7. Manejo de errores 32
7.1. Excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
7.2. Manejo de errores en programas concurrentes . . . . . . . . . . . 33
7.3. Mecanismos para el manejo de errores . . . . . . . . . . . . . . . 33
7.4. Tolerancia de fallas . . . . . . . . . . . . . . . . . . . . . . . . . . 34
8. Programacion distribuida 34
8.0.1. Creacion de un Nodo . . . . . . . . . . . . . . . . . . . . . 35
8.0.2. Distribucion en Erlang . . . . . . . . . . . . . . . . . . . . 35
8.0.3. Sockets . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9. Conclusiones 37
A. Aplicaciones de ejemplo 38
A.1. Un algoritmo de Backtracing . . . . . . . . . . . . . . . . . . . . 38
A.2. Chat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Referencias 47
2
Erlang
1. Introducci on
Primero que todo, Erlang es un lenguaje de programacion funcional. De
seguro alguna vez todos han trabajado con lenguajes imperativos, y las sen-
tencias como i++ nos resultan normales; en la programacion funcional esto no
esta permitido. De hecho, cambiar el valor de cualquier variable esta estricta-
mente prohibido! Esto podra resultar extra no a la primera impresion, pero si
recordamos las clases de matematicas, es de hecho lo que all aprendimos!
En Erlang tambien hay un gran enfasis en la concurrencia y alta conabili-
dad. Para ser capaz de tener decenas de tareas ejecutandose al mismo tiempo,
Erlang usa el modelo actor, y cada actor es un proceso separado en la maquina
virtual. En otras palabras, si una persona fuera un actor en el mundo de Erlang,
sera una persona solitaria, sentada en una habitacion a oscuras sin ventanas,
esperando que su buzon reciba un mensaje. Una vez que recibe un mensaje,
reacciona a el de una forma especca: pagar la factura de los servicios cuando
los recibe, responder cartas de feliz cumplea nos e ignorar las cartas que no puede
interpretar.
En Erlang todos se comunican estrictamente a traves de cartas. Suena
a una vida muy aburrida, pero esto signica que uno puede pedir a muchas
personas que realicen varias tareas especcas por el, y ninguno de ellos hara algo
mal o cometera un error que tenga repercusiones en el trabajo del resto; inclusive
no sabran de la existencia del resto de la gente.
Saliendo de esta analoga, Erlang fuerza a escribir actores (procesos) que no
compartan informacion con otros bits de codigo a menos que se pasen mensajes
uno a otro. Cada comunicacion es explcita, trazable y segura.
Este lenguaje nace a partir de necesidades del mercado, para cubrir cierto
tipo de problemas que necesitaban modelizarse de determinada forma.
La eciencia para el manejo de concurrencia, la transparencia para la pro-
gramacion distribuida y la madurez de sus bibliotecas de extension, lo hacen
particularmente apto para desarrollos vinculados a sistemas que necesitan cor-
rer indenidamente y que deben ser tolerantes a fallas. Mas a un si sumamos
el aprovechamiento de los multiprocesadores, que hicieron que el interes en el
lenguaje se renueve en los ultimos a nos.
Cuando denimos a Erlang, lo hicimos a nivel lenguaje, pero en un sentido
mas amplio, no es solo eso: Erlang es tambie n un ambiente de desarrollo en su
totalidad. El codigo es compilado a bytecode y corre dentro de una maquina
virtual. Entonces Erlang, al igual que Java, puede correr en cualquier lado.
La distribucion estandar incluye (entre otras cosas) herramientas de desarrol-
lo (compilador, debugger, proler, test framework), el Open Telecom Platform
(OTP) Framework, un web server, un generador de parser, y la base de datos
mnesia, un sistema de almacenamiento por key-value capaz de replicarse en var-
ios servidores, que soporta transacciones embebidas y permite guardar cualquier
tipo de datos Erlang.
La VM y las libreras tambien permiten actualizar el codigo de un sistema en
ejecucion sin interrumpir cualquier programa, distribuir el codigo con facilidad
en muchas computadoras y manejar errores y fallas de una forma simple pero
3
Erlang 1.1 Filosofa
poderosa.
Actualmente hay gran disponibilidad de libros tecnicos y teoricos, papers,
tutoriales y tesis referentes a Erlang y sus caractersticas. Nos ha llamado par-
ticularmente la atencion como muchos desarrolladores experimentados que han
pasado por diversos paradigmas, en especial el de la orientacion a objetos, se
han volcado hacia estos lenguajes hbridos cuya area de cubrimiento es especca
(en este caso, la concurrencia y la distribucion).
1.1. Filosofa
Citando a Mike Williams, uno de los tres creadores de Erlang, losofa de
Erlang se resume en tres items:
Encontrar los metodos correctos Dise no por prototipos
No es bueno solamente tener ideas, debes tambien ser capaz de implemen-
tarlas y saber que funcionan.
Cometer errores en peque na escala, no en un proyecto de produccion.
Lo primero en lo que tenemos que pensar cuando escuchamos el nombre
Erlang es en concurrencia. La concurrencia es el objetivo de Erlang.
Si analizamos la estructuracion del lenguaje distinguimos sus estructuras
funcional y concurrente, pero la primera no es sino una decision de dise no para
facilitar la segunda: la memoria compartida y la concurrencia no se llevan bien.
La programacion declarativa evita efectos secundarios; imponiendo un modelo
funcional, Erlang elimina el uso de locks, sincronizacion, semaforos, etc., simpli-
cando dramaticamente la cantidad de codigo y analisis usualmente asociados
a la programacion concurrente.
Erlang esta pensado para programar sistemas de tiempo real, preparados
para funcionar por largos perodos (eternamente, seg un indica su creador),
en presencia de fallas, a partir de procesos livianos, independientes, que se co-
munican exclusivamente por pasaje de mensajes asncronos. El lugar fsico en
que tales procesos se ejecutan, sea en una maquina o en varias, o el sistema
operativo sobre el que lo hacen, no afecta al codigo.
1.1.1. Let it crash
Dise nar sistemas tolerantes a fallas es extremadamente difcil. Uno puede
intentar anticiparse y razonar acerca de todas las cosas que pueden ir mal en
determinado software y codicar defensivamente para estas situaciones, pero
en un sistema complejo es muy probable que una combinacion de eventos o
entradas conspiren contra el sistema a causa de una falla o bug.
Hay una losofa que en vez de tratar de manejar y recuperar de todos
los estados excepcionales o fallidos, incita a que simplemente el software falle
tempranamente y deje que los procesos se rompan, pero luego los recicla para
atender al proximo request. Esto le da al sistema una especie de autocuracion
4
Erlang 1.2 Historia
en donde este se recupera de una falla sin ceremonias, mientras que libera al
programador del manejo defensivo y excesivo de los errores.
Implementar la semantica let it crash y trabajar con esta mentalidad mejo-
rara casi cualquier aplicacion (no solo los sistemas de telecomunicaciones de
tiempo real). Al adoptar let it crash, la redundancia y la defensa contra los
errores estaran respaldados en la arquitectura en vez de tratar de anticipar
escenarios en el medio del codigo. Esto tambien hace que se implemente mas
redundacia a traves del sistema.
Let it crash se trata de desacoplar la aplicacion e introducir el reconocimiento
asincronico de las cosas que pueden ir mal de manera sorpresiva.
1.2. Historia
Es necesario poner en contexto el desarrollo de este lenguaje. El problema al
que se afrontaba en aquel entonces era de un tema muy especco: la telefona.
1.2.1. Prehistoria
Erlang se gesto en el Computer Science Laboratory en Ericsson Telecom AB
en 1986. Ericsson junto con Televerket habian desarrollado la central telef onica
AXE. AXE, la cual fue desarrollada en 1974 y programada en PLEX, era la
segunda generacion de centrales SPC (store program control) con la que a me-
diados de los 80 genero grandes ganancias a Ericsson.
Joe Armstrong comienza a trabajar en Ericsson y se le encarga la tarea de
desarrollar un nuevo sistema de telefona. La primera motivacion para desarrol-
lar Erlang fue: hacer algo como PLEX, que corra en hardware ordinario, solo
que mejor.
Erlang heredo muchas caractersticas de AXE/PLEX. Entre ellas, la posibil-
idad de cambiar el codigo on the y y el hecho de que los procesos son inde-
pendientes del sistema operativo. Tambien fue importante considerar el pasaje
de mensajes entre procesos para compartir informacion y no usar memoria com-
partida a la que todos los procesos pudieran acceder.
Era primordial tener en cuenta los tiempos que tomaba crear un proceso, el
tiempo que tarda realizar el context switching entre procesos y el tiempo que se
tarda en copiar un mensaje de un proceso a otro.
5
Erlang 1.2 Historia
Figura 1: Ejemplo de modelo en Plex
Los requerimientos que hereda Erlang de Plex/AXE fueron:
Manejar un gran n umero de actividades concurrentes
Las acciones son ejecutadas en algun momento y dentro una cierta canti-
dad de tiempo
Sistemas distribuidos en varias computadoras
Interaccion con el hardware
Software muy grande
Funcionalidad compleja como la interaccion caracterstica
Operacion continua durante muchos a nos
6
Erlang 1.2 Historia
Mantenimiento de software (reconguracion, etc.) sin detener el sistema
Calidad rigurosa y requerimientos de conabilidad
Tolerancia a fallas tanto para errores de hardware y software
La primera forma de encarar el proyecto fue programar POTS (Plain Ordi-
nary Telephone Service) en diferentes lenguajes. Por suerte Ericsson era propi-
etario del hardware necesario para jugar con Unix y de una central telefonica
modicada que permita ser manejada por un VAX11/750.
Figura 2: Vax-11/750, llamada Comet. La CPU tena un tiempo de ciclo de 320
ns (3.125 MHz).
Se programaron SPOTS en Ada, Concurrent Euclid, PFL, LPL0, Frames y
CLU. Joe Armstrong contibuyo al proyecto programando POTS en Smalltalk.
Los POTS en Smalltalk eran excesivamente lentos. Sin embargo, Armstrong
habia desarrollado una notacion que permita modelar el proceso de llamada.
Esta funcion a su vez lanza dos procesos: un loop que lee constantemente los
mensajes recibidos al nodo y los imprime por consola (rloop), y otro que lee el
texto ingresado para enviarlo al otro nodo (wloop).
Como segundo ejercicio se busco representar una situacion mas realista,
seg un el modelo cliente-servidor: un nodo servidor, de ubicacion conocida, ad-
ministra la conversacion entre todos los nodos que se conectan a el, recibiendo
los mensajes y redistribuyendolos a los demas. De esta forma cada usuario se
comunica unicamente con el servidor, y desconoce a los otros nodos.
43
Erlang A.2 Chat
-module(server).
-export([start/0]).
start() ->
register(server, spawn (fun() -> loop([]) end)).
loop(Users) ->
receive
{From, join, Nick} ->
event(##++ Nick ++ se unio a la conversacion.\n,
Users),
From ! ##Te has unido a la conversacion.\n,
io:format(##++ Nick ++ joined. \n),
loop([{From, Nick}|Users]);
{From, leave} ->
{ ,{ ,Nick}} = lists:keysearch(From, 1, Users),
event(##++ Nick ++ abandono la conversacion.\n,
Users),
io:format(##++ Nick ++ left. \n),
loop(lists:keydelete(From,1,Users));
{From, users} ->
S = lists:flatten(lists:map(fun({ ,U})-> U ++ , end,
Users)),
Msg = ##Usuarios conectados: ++ S ++ \n,
From ! Msg,
loop(Users);
{From, Msg} ->
{ ,{ ,Nick}}= lists:keysearch(From, 1, Users),
event(Nick ++ : ++ Msg, lists:keydelete(From,1,
Users)),
loop(Users)
end.
event(Msg, Users) ->
lists:foreach( fun ({Pid, }) -> Pid ! Msg end,Users).
Al iniciar el server con start(), se registra el proceso servidor como server,
para poder ser identicado por los usuarios que le enviaran mensajes. Se inicia
un loop de lectura que realiza distintas acciones, de acuerdo a la forma del
mensaje que recibe: agregar o retirar a un usuario de la conversacion, informar
44
Erlang A.2 Chat
los nombres de los usuarios conectados, o reenviar un mensaje enviado por
alguno de esos usuarios. El cliente, similar al primer modulo realizado, ejecuta
bucles de lectura y escritura en consola, formateando el mensaje enviado al
servidor de manera especial, en caso de requerir abandonar la conversacion, o
conocer los usuarios conectados.
-module(client).
-export([join/2]).
join(ServerNode, Nick) ->
net adm:ping(ServerNode),
Pid = spawn(fun()-> rloop() end),
{server, ServerNode}!{Pid, join, Nick},
spawn(fun()-> wloop(ServerNode, Pid) end),
io:get line(decir: ).
rloop()->
receive
Msg ->
{H, M, S} = erlang:time(),
io:format((p:p:p) ++ Msg, [H, M, S]),
rloop()
end.
wloop(ServerNode, Pid)->
case io:get line(decir: ) of
#exit\n->
{server, ServerNode} ! {Pid, leave};
#users\n->
{server, ServerNode} ! {Pid, users},
wloop(ServerNode, Pid);
Msg ->
{server, ServerNode} ! {Pid, Msg},
wloop(ServerNode, Pid)
end.
Se incluye por ultimo una captura de este ultimo ejemplo funcionando en
varios nodos en una misma maquina.
45
Erlang A.2 Chat
Figura 20: ejemplo de ejecucion.
46
Erlang REFERENCIAS
Referencias
[1] Alfred Aho, John Hopcroft, and Jerey Ullman. Data Structures and Al-
gorithms. Addison-Wesley, 1983.
[2] Joe Armstrong. The development of Erlang. ACM SIGPLAN International
Conference on Functional Programming, 1997.
[3] Joe Armstrong. Making reliable distributed systems in the presence of soft-
ware errors. Royal Institute of Technology, 2003.
[4] Joe Armstrong. Programming Erlang: Software for a Concurrent World.
Pragmatic Bookshelf, 2007.
[5] Bjarne Dacker. Concurrent Functional Programming for Telecommunica-
tions: A Case Study of Technology Introduction. Royal Institute of Tech-
nology, 2000.
[6] Bogumil Hausman. Turbo Erlang: Approaching the Speed of C. Kluwer Aca-
demic Publishers, 1994.
[7] Peter Van Roy, and Seif Haridi. Concepts, Techniques, and Models of Com-
puter Programming. MIT Press, 2004.
[8] Erlang/OTP Publications. http://www.erlang.se/publications/
[9] Apache vs. Yaws. http://www.sics.se/joe/apachevsyaws.html
47