Diferencia entre revisiones de «Programación en Erlang»
Contenido eliminado Contenido añadido
m Bot: Corrigiendo la sintaxis del código wiki; cambios triviales |
|||
Línea 53:
Se supone que usted tiene el archivo comprimido tar, el nombre de las cuales es <prefix>. tar.gz, donde <prefix> es una cadena que denota la versión particular Erlang/OTP, por ejemplo, otp LXA 11930 sunos5 R9B.
Cualquiera que sea
El archivo no tiene un solo directorio en el que se guardan todos los demás archivos. Por tanto, el archivo debe ser extraído en un directorio vacío de directorio.
Línea 66:
:Por ejemplo:
::'''cd otp r7b'''
* Suponiendo que el archivo comprimido tar
:'''gunzip -c <SOME-DIR>/<PREFIX>.tar.gz | tar xfp –'''
* Lea el archivo README en el directorio de instalación por actualizaciones de última hora, antes de proceder.
Línea 177:
Erlang es un poco diferente a otros lenguajes funcionales como Haskell.
En Erlang primero se tiene que crear un modulo con extensión erl. Cada instrucción termina con un punto, sino se hace esto el compilador no se da cuenta cuándo acaba la instrucción. En el archivo creado hay que escribir: -module(archivo.erl). Donde archivo es el nombre del documento que se creó. Después se exportan las funciones que se pueden usar por la consola mediante la instrucción: -export([función/1]). Para compilar el código se escribe en la consola c(archivo). Esto compila el programa. El número que acompaña el nombre de la instrucción dice cuántos parámetros acepta.<br />
''Cree un archivo en “C:\Program Files\erl5.7.2\usr” o escriba “pwd().” Para saber a dónde debe crear los módulos.
==== Primer.erl ====
Línea 188:
"hello world".
<br />
Para compilar escriba en el Shell c(primer). Acuérdese de los puntos al final de la instrucción. Para ejecutar las funciones de los modulos en el Shell usted debe escribir: “modulo:función(parametros).” Por tanto este programa se ejecuto: “primer:hello_world().”.<br />
1>c(primer).
Línea 197:
3>
== Diccionario de palabras reservadas ==
=== Palabras Reservadas ===
Las palabras reservadas en Erlang son las siguientes:
{|Border=2
Línea 245:
|}
== Operadores y Simbolos del lenguaje ==
=== Operadores de Control ===
{|Border=2
Línea 272:
Erlang puede ser un poco confuso ya que existen 2 tipos de separadores de comando. La , se utiliza para separar expresiones. Esto generalmente se utiliza cuando se tiene una expresión después de otra como es en la programación secuencial. El separador ; es utilizado cuando existen distintos niveles de comandos que necesitan ser finalizados como en el caso de case o guard. El . se utiliza para terminar una función (o expresión, si se está corriendo desde la consola). Los comentarios inician con un % y cubre el resto de la oración pero lo el final, el final de un comentario es marcado por un “ “ (espacio).
=== Expresiones Aritmeticas ===
{|Border=1
|-
Línea 321:
1
=== Operadores Áritmeticos de Bit a Bit ===
{|Border=4
|-
Línea 367:
called as 1 bsl 18446744073709551616
=== Operadores Lógicos ===
{|Border=4
|-
Línea 399:
called as true or garbage
== Tipos de datos fundamentales disponibles en el lenguaje ==
=== Condiciones ===
Un pedazo de datos de cualquier tipo de datos se llama un '''término'''.
=== Números ===
Hay dos tipos de literales numéricos, ''enteros'' y ''carrozas''. Además de la notación convencional, hay dos Erlang-notaciones específicas:
* $ Char
El valor ASCII de los caracteres de caracteres.
*# base de valor
Entero con la base de base, que debe ser un entero en el rango de 2 .. 36.
=== Atoms ===
Un átomo es un literal, una constante con nombre. Un átomo debe estar entre comillas simples ( ') si no empiezan con una letra minúscula o si contiene caracteres que no sean caracteres alfanuméricos, guiones bajos (_), o @.
=== Bit Cuerdas y Binarios ===
Una cadena de bits que se utiliza para almacenar un área de memoria sin tipo. Cadenas se expresan mediante la sintaxis de bits. Las cadenas de bits que consta de un número de bits que es divisible por ocho son llamados '''Binarios'''
=== Referencia ===
Una referencia es un término que es único en un sistema de tiempo de ejecución de Erlang, creado por llamar make_ref / 0.
=== Fun ===
Funs hacer posible la creación de una función anónima y pasa a la función por si misma - no su nombre - como argumento a otras funciones.
Línea 429:
3
=== Tupla ===
Compuesto de tipo de datos con un número fijo de términos:
Línea 436:
Cada término de duración en la tupla se llama un elemento. El número de elementos se dice que es el tamaño de la tupla. Existe un número de BIFS para manipular tuplas.
=== Lista ===
Compuesto de tipo de datos con un número variable de los términos.
Línea 445:
Ejemplo:
[] Es una lista, por lo tanto <br />
[c | []] es una lista, por lo tanto <br />
[b | [c |[]]] es una lista, por lo tanto <br />
[a,b,c] . [a | [b | [c |[]]]] es una lista, o en definitiva [a, b, c]. <br />
Una lista en la cola es una lista se llama a veces una lista adecuada. Se permite tener una lista en la que la cola no es una lista, por ejemplo, [a | b]. Sin embargo, este tipo de lista es de poca utilidad práctica.
Línea 459:
Una colección de funciones de procesamiento de la lista se puede encontrar en las listas stdlib módulo.
=== String ===
Las cadenas se escriben entre comillas ( "), pero no es un tipo de datos en Erlang. En lugar de una cadena" Hola "es la abreviatura de la lista [e $ $ h,, $ l, l $, $ o], que es [ 104.101.108.108.111].
Dos cadenas literales adyacentes se concatenan en una sola. Esto se hace en tiempo de compilación y no incurrir en gastos de tiempo de ejecución.
Línea 469:
"string42" "string42"
=== Registro ===
Un registro es una estructura de datos para almacenar un número fijo de elementos. Sin embargo, registro no es un tipo de datos real. Las expresiones de registro son traducidos a tupla expresiones durante la compilación. Por lo tanto, las expresiones de registro no son comprendidos por el depósito si no se adoptan medidas especiales.
Línea 483:
(persona,Ernie,44)
=== Boolean ===
No hay ningún tipo de datos Boolean en Erlang. En cambio los átomos de verdadero y falso se usa para designar a los valores booleanos.
== Operaciones de entrada y salida básicas ==
Al ser Erlang un lenguaje funcional, comparte muchas cosas con Haskell.
=== Operaciones de entrada ===
Como muchos lenguajes funcionales Erlang posee su propio Shell en el cual se puede escribir directamente código y evaluarlos (correrlos) para así ver que pasa.
Línea 507:
2>
=== Operaciones de salida ===
Al igual que en la mayoría de los lenguajes funcionales, no se envía mensajes de salida, sino que estos envían respuestas a las entradas.
Línea 526:
Asi que como vemos, al igual que en Haskell.
== Tipos de datos complejos y su representación ==
=== Registros ===
Un registro es una estructura de datos con un número fijo de campos que se accede por su nombre, similar a una estructura de C o un registro de Pascal. Esto difiere de tuplas, donde los campos son visitados por la posición. En el caso del ejemplo de persona, defina un tipo de registro
como sigue:
Línea 556:
donde las partes entre corchetes son las declaraciones opcionales de valores de campo por defecto. El mismo nombre de campo se puede utilizar en más de un tipo de registro; de hecho, dos registros podrían compartir la misma lista de nombres. El nombre del registro puede ser utilizado en sólo una definición, sin embargo, como este se utiliza para identificar el registro.
=== Trabajando con Registros ===
Suponga que le dan un valor de registro. ¿Cómo se puede acceder a los campos, y cómo puede usted describir un registro modificado?. Teniendo en cuenta el siguiente ejemplo:
Línea 583:
donde los campo actualizados pueden ocurrir en cualquier orden, pero cada nombre de campo puede ocurrir, como máximo, sólo una vez.
=== Implementación de registros ===
El compilador de Erlang implementa registros antes de que se ejecute programas. Los registros se traducen tuplas, y funciones en los registros se traducen en funciones y BIFs sobre el
tuplas correspondientes.
Línea 592:
{person, 'Joe', 'Armstrong'} {person, 'Mike', 'Williams'}
=== Listas ===
Listas y tuplas se utilizan para almacenar colecciones de elementos; en ambos casos, los elementos pueden ser de diferentes tipos, y las colecciones pueden ser de cualquier tamaño. Las listas y las tuplas son muy diferentes, sin embargo, en la forma en que pueden ser procesados. Comenzaremos por describir cómo las listas se denotan en Erlang, y examinar la forma en que las cadenas son un tipo especial de lista, antes de explicar en detalle cómo las listas pueden ser procesadas.
Línea 611:
a, la segunda es la lista [b, [c, d, e], f], y el tercero es el átomo g. La lista vacía es denotada por [], mientras que [{person, 'Joe', 'Armstrong'}, {person, 'Robert', 'Virding'}, {person, 'Mike', Williams'}] es una lista de tuplas etiquetadas.
=== Arrays ===
El módulo array contiene un tipo de dato abstracto funcional, matrices extendibles. Pueden tener un tamaño fijo, o crecer según sea necesario. El módulo contiene la funcionalidad para establecer y revisar los valores, así como para definir recurrencias sobre ellos.
Línea 654:
{'EXIT',{badarg,_}} = (catch array:get(18, A3)).
=== Estructura de Datos Complejas ===
Cuando nos referimos a términos de Erlang, nos referimos a estructuras de datos legales. Los Términos Erlang pueden ser valores de datos simples, pero a menudo utilizamos la expresión para describir arbitrariamente estructuras de datos complejas.
En Erlang, las estructuras de datos complejas son creados anidadando tipos de datos compuestos. Estas estructuras de datos puede contener variables ligadas o los valores simples y compuestos ellos mismos. Un ejemplo de una lista que conteniendo tuplas tipo person (etiquetados con el átomo person) con el nombre, apellido, y una lista de atributos que se vería así:
Línea 696:
== Declaración e Inicialización de Variables ==
=== Tipos de Variables ===
Erlang maneja diferentes tipos de variables, los cuales se dividen en 2:
# Constantes: estos tipos de dato son los que ya no son divisibles en más datos primitivos. Las Constantes pueden ser de 2 tipos:
## Números. Los números caben dentro de 2 tipos. Los tipos son:
### Enteros (Ejemplos: 120, -35000, 590, etc.)
### Flotantes (Ejemplos: 3.14159, -1.2e-45, 30.141216, etc.)
## Átomos.
# Compuestos: estos son los tipos de dato que se usan para agrupar datos. Los tipos son:
## Tuplas. Las tuplas son usadas para almacenar un número fijo de datos y se utilizan mediante ‘{}’. Las tuplas son similares a los registros o estructuras para los lenguajes funcionales. (Ejemplo: {a,12,77},{},{1,2,3},etc.)
## Listas. Las listas son utilizadas para almacenar un número variable de datos y son escritos como secuencias de datos que son cerradas mediante ‘[]’. (Ejemplos: [], [1,2,3,34],[1,’Hola Mundo’],etc.)
=== Declaración de Variables ===
La declaración de variables es diferente a Erlang que a otros leguajes, ya que Erlang no define una variable de tipo int o float. Sino que este se da cuenta al volverse le a asignar. Las variables de Erlang son de simple asignamiento. Comienzan con una letra capital o un ‘underscore’ seguidas de un texto alfanumérico.
== Tabla de Operadores con Asociatividad y Precedencia ==
En expresiones que consisten de sub-expresiones los operadores serán desarrollados de acuerdo a su precedencia definida.
{|Border=1
Línea 755:
Los operadores con la prioridad más alta serán los primeros en evaluarse. Operadores con la misma prioridad serán evaluados por su asociatividad. Los operadores aritméticos con asociatividad por la izquierda son evaluados de izquierda a derecha.
Ejemplo: <br />
6 + 5 * 4 - 3 / 2
=== Expresiones booleanas de Corto Circuito ===
Ejemplo:
Línea 772:
if is_list(L) andalso length(L) == 1 -> ...
== Estructuras de decisión e iteración ==
=== IF ===
if
GuardSeq1 ->
Línea 796:
end
=== Case ===
La expresión expr es evaluado y el patrón de los patrones se comparan con la secuencia de resultados.
El valor de retorno del cuerpo es el valor de retorno de la expresión caso. Si no hay un patrón de coincidencia con una secuencia de la guardia real, una ejecución case_clause tiempo de error.
Línea 808:
end
== ITERACIONES Y RECURSIONES ==
=== Guard sequences ===
Una secuencia de guardia es un conjunto de guardias separados por punto y coma (;). La secuencia de guardia es cierto si al menos uno de los guardias es cierto.
GUARD1, ...; GuardK
Un guard es un conjunto de expresiones del
GuardExpr1, ..., GuardExprN
Las expresiones del Guard permitido (a veces se llaman pruebas de guard) es un subconjunto del conjunto de las expresiones válidas Erlang, desde la evaluación de una expresión de guard debe ser garantizado de estar libre de efectos secundarios.
Línea 879:
1. % second clause body
=== Tail Recursion ===
Si la última expresión de una
fact(N) when N>1 -> fact(N, N-1);
fact(N) when N=1; N=0 -> 1.
Línea 903:
Ejemplo 2:
Recursión con un
"counter4/1" consiste en dos clausulas separadas por ;
Línea 935:
count_matrix1(Size, PtrX+1, PtrY).
== Declaración, definición y uso de métodos y funciones ==
=== Métodos y funciones en Erlang ===
Para ver una función en Erlang podemos el archivo even_prime.er con el siguiente código
-module(even_prime).
-export([is_even_prime/1]).
% 3
is_even_prime(2) ->
true; % 5
is_even_prime(N) when is_integer(N) ->
false; % 7
is_even_prime(Any) ->
'I prefer integer inputs'. % 9
Las clausulas de las funciones están puestas en el orden en el cual se verifican. Primero is_even_prime(2) es verificada para ver si concuerda. Si el argumento es verificado dicha función regresa verdadero. Si is_even_prime(2) no es verificada, entonces se trata is_even_prime(N). is_even_prime(N)
Salidas
2> c(even_prime).
Línea 963:
'I prefer integer inputs'
=== Estructura de una función ===
<nowiki>==================================================================</nowiki>
Syntax/structure of a function:
Línea 983:
<nowiki>==================================================================</nowiki>
== Implementación y uso de la Programación Orientada a Objetos ==
=== Objetos ===
Erlang no tiene explícitamente incorporado características de lenguaje orientado a objetos. Un estilo de programación orientado a objetos se puede lograr por otros medios fácilmente. Es especialmente fácil de hacer programación orientada a objetos, si nos limitamos a la herencia simple. Se puede utilizar procesos para representar a las clases y mensajes para representar a los métodos. Para ello, cada objeto cuando se creó puede crear una cadena de procesos que representan a sus antepasados en la cadena de herencia. Los métodos (mensajes) se puede pasar por la cadena hasta llegar a un proceso que tiene un método de emparejamiento. Si el mensaje llega a la cima de la cadena (la clase objeto o superior que dev_nul), entonces podemos generar una excepción para el “nombre de un método malo". Cada clase (proceso) mantendrá sus propios atributos (variables) en su propia lista recursiva de la llamada de argumentos. Estos atributos se pueden acceder y actualizar con mensajes así como get y set. Los atributos son almacenados en un diccionario llamado Bundle, en cada proceso de clase.
Línea 993:
Un mensaje (método) es enviado a una instancia de un objeto. Si un proceso no sabe cómo hacer algo, pasa un mensaje (método) a su padre (proceso en esta situación). Si tratamos de hacer algo como tomar la raíz cuadrada de una matriz diagonal será pasada hasta dev_nul y generara un error.
La función inicial crea una instancia de la clase entero. Después le pregunta a la instancia que calcule la raíz cuadrada de 4 números: 4, 0.04, -4 y la matriz [[4,0]],[[0,9]]. Las respuestas son: 2, 0.2, {2,i} y [[2,0]],[[0,3]].
== Esquema de Administración de Memoria y Separación de Memoria ==
maneja todos sus procedimientos a través del heap ya que este no utiliza stack. Hay varias estrategias utilizadas para el manejamiento y mantenimiento del Heap. Entre ellas están:
* “process local heap”
* “unified heap”
=== "Process Local Heap" ===
Esta estrategia lo que realiza es crear una heap local donde ubica cada objeto. Cada proceso llama una colección independiente. El recolector de basura trabaja por procesos.
=== "Unified Heap" ===
Esta estrategia toma que todos los heaps son uno sólo que comparte todos los procesos. Este heap almacena la continuación de los procesos y los otros objetos alojados por proceso. Sólo caundo la heap es acabada por uno de estos procesos que el recolector de basura es llamado. El algoritmo utilizado en el Erlang basado para los sistemas ETOS es una combinación entre two-spacecopying y mark-and-sweep.
=== Algoritmo del Recolector de Basura para “Process Local Heap” ===
El algoritmo se divide en 2 pasos. El primero de ellos, realiza una barrida de todo el heap y lo compacta. El último, mueve los objetos de regreso hasta su destinación final. La gran ventaja de este algoritmo es que no ocupa espacio adicional. Sin embargo, en el otro aspecto el tiempo de corrida de este algoritmo depende del tamaño del heap.
=== Manejamiento de Memoria para el “Unified Heap” ===
Para acomodarse al ambiente multitasking el unified heap puede crecer y achicarse así sea necesario en la evolución del programa que evidentemente se mantiene proporcional el tamaño del espacio de procesamiento del Sistema Operativo al de la data utilizada. Por el default, al final de un ciclo el tamaño del heap es redefinido para que quepa los datos ocupen la mitad del tamaño del heap.
=== Manejamiento de Procesos ===
La estrategia utilizada es un manejador de procesos por prioridad. Cada proceso tiene un número de punto flotante marcando su prioridad. Esto otorga un buen control, de cuando deben entrar y salir los procesos.
=== Paso de Parametros ===
Erlang del “Process Local Heap” realiza una copia para pasar los parámetros de diferentes procesos. Ya que cada proceso tiene una colección diferente es por esta razón la necesidad de una copia. Sin embargo, gracias a que el “Unified Heap” toman la heap como un todo el paso de parámetros mediante procesos no genera un problema como en el “Process Local Heap”.
== Implementación de Corutinas ==
=== Procesos ===
Erlang, a diferencia de otros lenguajes funcionales, tiene la capacidad de manejar concurrencia y programación distribuida. Concurrencia es poder manejar varios hilos de ejecución al mismo tiempo. Por ejemplo, sistemas operativos modernos le permitirían utilizar un procesador de textos, una hoja de cálculo, un cliente de correo y un trabajo de impresión todo esto ejecutándose al mismo tiempo. Por supuesto cada procesador (CPU) en el sistema probablemente sólo maneja un hilo (o trabajo) a la vez, pero cambia entre los trabajos a una velocidad que da la ilusión de correrlos todo al mismo tiempo. Es fácil crear hilos paralelos de ejecución en Erlang y es fácil permitir que estos hilos se comuniquen unos con otros. En Erlang a cada hilo de ejecución se le denomina proceso.
Nota: El término "proceso" es utilizado, generalmente, cuando los hilos de ejecución no comparten datos uno con el otro y el termino "hilo" cuando ellos comparten datos de alguna manera. Los hilos de ejecución en Erlang no comparten datos, por eso se llaman procesos.
Línea 1061:
spawn(tut14, say_something, [goodbye, 3]).
spawn retorna el identificador de un proceso (Process Identifier o pid), este identifica de manera unica un proceso.Asi que
Nota: Observe que en io:format se utilize ~p en vez de ~w. Esto es así ya que, ~p escribe la data en una sintaxis estándar, de la misma manera que ~w, sin embargo este rompe los terms que al imprimir son más largos de una línea en varias líneas y las indenta de manera coherente. También intenta detectar listas con caracteres imprimibles e imprimirlos como strings.
=== Como enviar mensajes ===
En el siguiente ejemplo se crean dos procesos que se envían mensajes el uno al otro un determinado número de veces.
Ejemplo:
Línea 1180:
El atom finished es enviado a "pong" (causando que el proceso termine) y se imprime "ping finished" en la ventana. "Ping" al no tener nada que hacer se finaliza.
== Registrando el Nombre de Procesos ==
En el ejemplo anterior, primero se creo "pong" para poder darle la identidad de “pong” a “ping” al ser iniciada. En otras palabras, “ping" debe saber la identidad de “pong” para poder enviarle algún mensaje. Algunas veces los procesos que necesitan saber la identidad de otros son iniciados completamente independientes uno del otro. Erlang provee mecanismos para dale nombres a los procesos y así utilizar estos nombres como identidades en vez de los pids. Esto se hace utilizando la BIF register:
register(some_atom, Pid)
Línea 1237:
== Manejo de Excepciones ==
=== Mecanismos de excepciones: catch y throw ===
throw(expresión) evalúa la expresión y proporciona el resultado al catch más cercano. Puede usarse para generar un mensaje de error.
(catch expresión) evalúa la expresión, y si captura un mensaje de error genera una estructura de datos, bien la generada por throw o la generada por el propio sistema.
Los mensajes de error proporcionados por el sistema suelen ser bastante descriptivos:
* badarg si se le pasa un argumento incorrecto a una función,
* badarith si se intenta hacer una operación con argumentos inadecuados,
* badmatch si se intenta concordar con un patrón que no encaja,
* case_clause si ninguna cláusula en un case sirve para un argumento dado...
=== Programación defensiva ===
Hay dos formas de corregir errores provocados por la entrada de datos
incorrectos en el sistema:
* Comprobar los datos antes de usarlos.
* No comprobar los datos, sino recuperarse cuando ocurre un error.
La prevención de errores añade código poco útil para el sistema, incrementando el tamaño y la complejidad del mismo. Si la aparición de errores es infrecuente, es preferible no desperdiciar tiempo comprobando cada dato, ahorrando así tiempo en el caso frecuente de que no haya errores.
=== Reemplazo de código en caliente ===
La unidad mínima de reemplazo de código es el módulo. Dos versiones distintas del mismo módulo pueden estar cargadas en memoria al mismo tiempo. Cuando se realiza una llamada a una función se utiliza la última versión disponible del modulo.
=== Catch and Throw ===
Devuelve el valor de expr a menos que se produce una excepción durante la evaluación. En ese caso, se detecta la excepción. Para las excepciones de error de la clase, es decir, errores de ejecución: ( 'EXIT', (Razón, Stack)) es devuelto. Para las excepciones de la salida de clase, que es el código de llamada de salida (término): ( 'EXIT', término) es devuelto. Para las excepciones de la clase de tiro, que es el código de llamada tiro (term): Término se devuelve.
Razón depende del tipo de error que se produjo, y la pila es la pila de llamadas a funciones más recientes, ver los errores y tratamiento de errores.
Línea 1267:
Tenga en cuenta que aunque la captura de palabras clave se utiliza en la expresión de tratar, no es una expresión de captura dentro de la expresión intentarlo.
=== Try ===
Devuelve el valor de Exprs (una secuencia de expresiones Expr1, ..., exprn) a menos que se produce una excepción durante la evaluación. En ese caso la excepción es capturada y los patrones de ExceptionPattern con el derecho de clase de excepción de clase son de forma secuencial compara con la excepción capturada. Un omitirse la clase es la abreviatura de tiro. Si un partido tiene éxito y la secuencia opcional de la Guardia ExceptionGuardSeq es cierto, la ExceptionBody correspondiente se evalúa a convertirse en el valor de retorno.
Línea 1280:
end
== Gramática en EBNF del lenguaje ==
== Características específicas del Lenguaje ==
=== Constructores de Alto Nivel ===
Erlang es un lenguaje declarativo. Los Lenguajes declarativos trabajan sobre el principio de tratar
para describir lo que debe ser computado, en lugar de decir cómo se calcula este valor.
Una definición de función-particularmente uno que utiliza un patrón de coincidencia (pattern matching) para seleccionar entre diferentes casos, y para extraer los componentes de las estructuras complejas de datos, leerán como un set de ecuaciones.
=== Procesos concurrentes y paso de mensaje ===
Concurrencia en Erlang es fundamental para su éxito. En lugar de proporcionar hilos
de que comparten memoria, cada proceso de Erlang se ejecuta en su propio espacio de memoria y en su propia heap y stack. Los procesos no pueden interferir unos con otros sin darse cuenta, al igual que todos es fácil en modelado de hilos, dando lugar a bloqueos y otros horrores.
Línea 1293:
Los procesos se comunican entre sí mediante el paso de mensajes, donde el mensaje puede ser cualquier valor de dato Erlang en absoluto. El paso de mensajes es asincrónica, por lo que una vez que se envía un mensaje, el proceso puede continuar procesando. Los mensajes se recuperan del proceso de buzón de correo selectivamente, por lo que no es necesario procesar los mensajes en el orden en que se reciben. Esto hace que la concurrencia de más robusta, en particular cuando los procesos son distribuidos a través de diferentes equipos y el orden en que se reciben los mensajes dependerá de las condiciones de ambiente la red. La Figura 1-1 muestra un ejemplo, donde un "servidor de la zona" procesa calcular áreas de formas para un cliente.
=== Escalable, segura y concurrencia eficiente ===
La Concurrencia de Erlang es rápida y escalable. Sus procesos son de peso ligero en el que la máquina virtual de Erlang no crea un subproceso de sistema operativo para cada proceso creado. Se crean, programado, y manipulados en la máquina virtual, independiente del sistema operativo subyacente. Como resultado, el tiempo de proceso de creación es del orden de microsegundos e independiente del número de procesos existentes simultáneamente.
Los procesos de Erlang se comunican entre sí a través del paso de mensajes. A pesar de
Línea 1299:
sistema le toma microsegundos. Todo lo que está involucrado en el paso de mensajes es la copia de los datos del espacio de memoria de un proceso hacia el espacio de memoria del otro, todo dentro de la misma máquina virtual.
=== Propiedades livianas en tiempo real ===
A pesar de que Erlang es un lenguaje de alto nivel, se puede usar para tareas con limitaciones livianas en tiempo real. La gestión del almacenamiento en Erlang es automatizado, con la recolección de basura en práctica en función de cada proceso. Esto le da al sistema un tiempo de respuesta en el orden de milisegundos, incluso en la presencia de basura recolectada en la memoria. Debido a esto, Erlang puede manejar grandes cargas sin degradación en el rendimiento, incluso durante los picos de sostenido.
=== Robustez ===
¿Cómo se construye un sistema robusto? Aunque Erlang no puede resolver todos sus problemas, facilitará en gran medida su tarea en una fracción del esfuerzo de otros lenguages de programación. Gracias a una serie de simples pero potentes mecanismos de control de errores
pero usualmente contienen menos errores.
=== Coincidencia de patrones (Pattern Matching) ===
Coincidencia de patrones en Erlang se usa para:
* Asigna valores a las variables
* Control del flujo de ejecución de los programas
*
La combinación de estas características permite escribir conciso, legible y potente
Línea 1334:
* El patrón de concordancia pueden fallar, y ninguna variable se convierte en dependiente como consecuencia de ello.
== Ejemplos Pequeños del Lenguaje ==
Para entender mejor el lenguaje que mejor manera que con los ejemplos comunes de todos los lenguajes. Y así notar la diferencia entre Erlang y el resto.
==== factorial.erl ====
-module(factorial).
-export([factorial/1]).
Línea 1391:
|}
La diferencia entre ‘Exact’ y ‘Coerce’ es inmensa. Por ejemplo en ‘Coerce’ cuando comparamos 2 números solo compara magnitudes tal como 5.0 == 4+1. Sin embargo ‘Exact’ lo que hace es decir que no son iguales porque 5.0 no es igual a 5 ya que un entero no es similar a un punto flotante. <br />
Los casos tipos if, else y case se verán aplicados al mismo factorial para entender la diferencia.
==== Tipo If y Else ====
-module(factorial2).
Línea 1408:
Si se puede observar esto es como condición instrucción terminada en ‘;’ excepto la condición final.
==== Tipo Case ====
-module (factorial3).
Línea 1424:
Para demostrar un programa fácil pero con un poco más de complejidad haremos el cifrado de César con rotación 13.
==== Cifrado Cesar (Rotación 13) ====
El cifrado de cesar con rotación 13 mueve una letra 13 posiciones más adelante.<br />
-module (cesar).
Línea 1449:
Lo que aquí se aprecia es un nuevo tipo de instrucción. EL cual Erlang permite usar una lista y aplicarle una función a todos los elementos de la lista. De ahí la instrucción list_to_atom devuelve la lista de enteros como una lista de caracteres es decir una cadena.
== Apéndice A (¿Cómo Descargar Erlang?) ==
=== Windows ===
Los pasos para instalar erlang son los siguientes:
* Descargar el archivo: [http://erlang.org/download/otp_win32_R13B01.exe "Página de Erlang"]
* Al descargarlo, ejecutarlo inmediatamente
* Seguir las instrucciones en el instalador
* Ejecutar el programa
=== Otros Sistemas Operativos ===
Los pasos son los siguientes:
* Deben ir a la página: [http://erlang.org/download.html "Página de Erlang(2)"]
* Descargar el código fuente de ser necesario y compilarlo.
* Descargar la documentación de la página
* Asegurarse de descargar los archivos del mismo tipo.
== Fuentes ==
Armstrong, J., Virding, R., Wikström, C., & Williams, M. (1996). Concurrent Programming in ERLANG. Älvsjö: Prentice Hall.<br />
Feely, M. (s.f.). CiteSeerX. Recuperado el 17 de Septiembre de 2009, de CiteSeerX: A case for the unified heap approach to Erlang memory management (2001): [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.20.9664 "Heap Approach Erlang"]<br />
Wikipedia. (s.f.). Erlang Programming/Pattern Matching. Recuperado el 17 de Septiembre de 2009, de Wikipedia:Erlang Programming/Pattern Matching: [[:m:b:en:Erlang_Programming/Pattern_Matching|"Pattern Matching"]]<br />
| |||