A **linguaxe Erlang** é unha linguaxe de programación concorrente e un sistema de execución que inclúe unha máquina virtual e librerías.

O subconxunto de programación secuencial de Erlang é un linguaxe funcional, con avaliación estrita, asignación única, e tipado dinámico. Foi deseñado na compañía Ericsson para realizar aplicacións distribuídas, tolerantes a fallos, soft-real-ware e de funcionamento ininterrompido. Proporciona o cambio en quente de código de forma que este pódese cambiar sen parar o sistema. Orixinalmente, Erlang, era unha linguaxe propietaria de Ericsson, pero foi cedido como open source en 1998.

A introdución de Ericsson é, principalmente interpretada pero tamén inclúe un compilador HiPE (só soportado nalgunhas plataformas).
A creación e xestión de procesos é trivial en Erlang, mentres que, en moitas linguaxes, os fíos considéranse un apartado complicado e propenso a erros. En Erlang toda concorrencia é explícita.

Erlang recibe o nome de A. K. Erlang. Ás veces pénsase que o nome é unha abreviación de **ER**icsson **LANG**uage, debido ao seu uso intensivo en Ericsson. Segundo Bjarne Däcker quen foi o xefe do Computer Science Lab no seu día, esta dualidade é intencional.

Historia
--------

Linguaxe funcional
------------------

O código fonte ten este aspecto:

```
**-module**(fact).
**-export**([fac/1]).

fac(0) -> 1;
fac(N) **when** N > 0 -> N * fac(N-1).
```

A continuación unha introdución do algoritmo Quicksort.

```
*%% quicksort:qsort(List)*
*%% Ordena unha lista de elementos*
**-module**(quicksort).
**-export**([qsort/1]).

qsort([]) -> [];
qsort([Pivot|Rest]) ->
    qsort([ X || X <- Rest, X < Pivot]) ++ [Pivot] ++ qsort([ E || E <- Rest, E >= Pivot]).
```

O exemplo anterior chama recursivamente á función `qsort` ata que non hai nada máis para ordenar. A expresión `[ X || X <- Rest, X < Pivot]` pódese interpretar como: "Elixe todo `X` onde `X` é membro de `Rest` e `X` é menor que `Pivot`", resultando nun forma moi sinxela de manipular listas. Como se pode avaliar calquera expresión boleana entre dous tipos de datos diferentes, a avaliación é sinxela: por exemplo, `1 </code<> devolverá `true`.`

`Con todo, unha función de comparación pódese usar se é necesario cambiar a orde en que Erlang basea o seu valor de retorno (`true` or `false`) Por exemplo, se quixeramos unha lista ordenada onde `a 1`  fose avaliado como `true`.

O seguinte código ordenaría un lista en función da lonxitude:

```
**-module**(listsort).
**-export**([by_length/1]).

by_length(Lists) ->
    F = fun(A,B) when is_list(A), is_list(B) ->
            length(A) < length(B)
        end,
    qsort(Lists, F).

 qsort([], _) -> [];
 qsort([Pivot|Rest], Smaller) ->
     qsort([ X || X <- Rest, Smaller(X, Pivot)], Smaller)
     ++ [Pivot] ++
     qsort([ E || E <- Rest, not(Smaller(E, Pivot))], Smaller).
```

Linguaxe orientada a concorrencia e distribución
------------------------------------------------

A maior fortaleza de Erlang é o soporte para concorrencia. Ten un pequeno pero potente conxunto de primitivas para crear procesos e comunicar entre os mesmos. O modelo de procesos baséase en C.A.R. Hoare's Communicating Sequential Processes. Devanditos procesos son a forma principal de estruturar unha aplicación, e pódese crear un gran número deles sen que se degrade o rendemento (chegouse a facer unha proba con 20 millóns de procesos).

O soporte para procesos distribuídos é tamén parte de Erlang. Os procesos pódense crear en nodos remotos, e a comunicación con eles é transparente. É dicir, a comunicación con procesos remotos faise exactamente da mesma xeito que a comunicación con procesos locais.

Exemplos:

```
 Pid = **spawn**(Mod, Func, Args)       *% executar a función Func como un novo proceso*
 Pid = **spawn**(Node, Mod, Func, Args) *% executar a función Func nun nodo remoto*

 Pid ! a_message      *% enviar unha mensaxe ao proceso (asíncronamente)*

 **receive**       *% recibir a mensaxe enviada a este proceso*
   a_message -> do_something
 **end**.
````

A principal forma de control de erros en Erlang tamén se basea na concorrencia. Cando un proceso cólgase, termina limpamente e envía unha mensaxe ao proceso controlador quen pode actuar en consecuencia. Esta forma de control de erros pode incrementar a mantenibilidad e reducir a complexidade do código.

Distribución
------------

Erlang foi feito público por Ericsson como código aberto para asegurar a súa independencia dun único vendedor e para dalo a coñecer dunha forma máis ampla. A distribución da linguaxe xunto coas librerías e a base de datos de tempo real (*Mnesia*) denomínanse *Open Telecom Platform* (Plataforma aberta de Telecom), ou OTP. Ericsson e outras poucas empresas ofrecen soporte comercial para Erlang.

Desde que se colleu o camiño do código aberto en 1998, Erlang empezou a ser utilizado por varias compañías en todo o mundo, incluíndo Nortel e T-Mobile. De todos os xeitos, Erlang aínda non é unha linguaxe de programación moi estendido.

Na data actual (2006), existe un desenvolvemento activo de Erlang con edicións regulares. Está dispoñible para diversos sistemas operativos de tipo Unix e Microsoft Windows.

Véxase tamén
------------

### Ligazóns externas

* Páxina Web do proxecto
* presentación de Erlang
* Servizos de formación e consultoría de Erlang
* portal con moita información sobre Erlang: Howto, forums, wiki, FAQ, ...
* Process-one (Empresa que ofrece soporte de Erlang)
* Un portal dedicado a Erlang *(en inglés)*
* Unha xungla de código Erlang
* Repositorio de artigos e papers sobre Erlang
* ESense - Completado de código tipo IntelliSense para Erlang sobre Emacs

| * v
* c
* e
Linguaxes de programación |
| --- |
| Baixo nivel | 

|  |  |
| --- | --- |
| Primeira xeración | Código máquina |
| Segunda xeración | Assembly |

 |
| Alto nivel | 

|  |  |
| --- | --- |
| Terceira xeración | 
* A+
* ABC
* Algol
* B
* BASIC
* C
* C++
* C#
* COBOL
* CPL
* D
* E
* Fortran
* Go
* Java
* JavaScript
* Lisp
* Objective-C
* PL/1
* Pascal
* Smalltalk
* Visual Basic .NET

 |
| Cuarta xeración | 
* Clarion
* Clipper
* Clojure
* Common Lisp
* Erlang
* GNU Octave
* Haskell
* Lisp
* Lua
* Julia
* Perl
* PHP
* Prolog
* Python
* R
* Ruby
* Rust
* S
* Scilab
* Stata
* SQL

 |
| Quinta xeración | 
* Mercury
* OPS5
* Prolog

 |

 |
| 
* Ambiente de desenvolvemento
* Metaprogramación
* Programación a nivel funcional
* Programación estruturada
* Programación non estruturada
* Programación imperativa
* Programación modular
* Programación multidimensional
* Orientación a obxectos

 |

|  |  |
| --- | --- |
| Control de autoridades | 
* Wd: Q334879
* GND: 4324177-3
* LCCN: sh93000031
* MAG: 82484044

 |