Erlang

Erlang (ŋ lang) là ngôn ngữ lập trình đa năng, đồng thời, là ngôn ngữ lập trình hàm, và là một hệ thống thu gom rác được phát triển tại Phòng thí nghiệm Khoa học Máy tính của Ericsson. OTP (Nền tảng viễn thông mở) là một tập hợp các thư viện và phần mềm trung gian trong Erlang. Erlang / OTP đã được thử nghiệm trong một số sản phẩm của Ericsson để xây dựng các ứng dụng phân tán chịu lỗi mạnh mẽ, ví dụ AXD301 (công tắc ATM). Erlang / OTP hiện được duy trì bởi đơn vị Erlang / OTP tại Ericsson.
Nó cung cấp sự thay đổi nóng của mã để có thể thay đổi mà không cần dừng hệ thống. Ban đầu nó là phần mềm độc quyền trong Ericsson, được phát triển bởi Joe Armstrong, Robert Virding và Mike Williams vào năm 1986, nhưng nó được cho mượn dưới dạng phần mềm nguồn mở vào năm 1998. Việc triển khai của Ericsson chủ yếu được diễn giải, nhưng nó cũng bao gồm trình biên dịch HiPE (chỉ được hỗ trợ trên một số nền tảng).
Việc tạo, quản lý và giao tiếp các quy trình rất đơn giản trong Erlang, trong khi ở nhiều ngôn ngữ, các luồng được coi là một phần phức tạp và dễ bị lỗi. Trong Erlang tất cả sự đồng tình là rõ ràng.
Erlang nhận được tên của A. K. Erlang. Đôi khi người ta cho rằng tên này là tên viết tắt của ERicsson LANGuage, do được sử dụng nhiều trong Ericsson. Theo Bjarne Däcker - người đứng đầu Phòng thí nghiệm Khoa học Máy tính vào thời điểm đó - sự đối ngẫu này là có chủ ý.
Một trong những sản phẩm công nghệ nổi bật sử dụng công nghệ Erlang là WhatsApp được phát triển bởiJan Koum, Brian Acton năm 2009 và được  Facebook mua lại năm 2014 với giá trị 19 tỷ USD

**OTP**
OTP được thiết lập các thư viện Erlang và các nguyên tắc thiết kế cung cấp kho trung gian để phát triển các hệ thống này. Nó bao gồm cơ sở dữ liệu phân tán của riêng mình, các ứng dụng để giao tiếp với các ngôn ngữ khác, gỡ lỗi và phát hành các công cụ xử lý.

**Ví dụ về lập trình hàm**

**Tính giai thừa**
-module(fact). % This is the file 'fact.erl', the module and the filename must match
-export(fac/1). % This exports the function 'fac' of arity 1 (1 parameter, no type, no name)
fac(0) -> 1; % If 0, then return 1, otherwise (note the semicolon; meaning 'else')
fac(N) when N > 0, is_integer(N) -> N * fac(N-1).
% Recursively determine, then return the result
% (note the period. meaning 'endif' or 'function end')
%% This function will crash if anything other than a nonnegative integer is given.
%% It illustrates the "Let it crash" philosophy of Erlang.

**Dãy Fibonacci**
Thuật toán đệ quy đuôi tạo ra Dãy Fibonacci:
%% The module declaration must match the file name "series.erl" 
-module(series).
%% The export statement contains a list of all those functions that form
%% the module's public API.  In this case, this module exposes a single
%% function called fib that takes 1 argument (I.E. has an arity of 1)
%% The general syntax for -export is a list containing the name and
%% arity of each public function
-export(fib/1).
%% ---------------------------------------------------------------------
%% Public API
%% ---------------------------------------------------------------------
%% Handle cases in which fib/1 receives specific values
%% The order in which these function signatures are declared is a vital
%% part of this module's functionality
%% If fib/1 is passed precisely the integer 0, then return 0
fib(0) -> 0;
%% If fib/1 receives a negative number, then return the atom err_neg_val
%% Normally, such defensive coding is discouraged due to Erlang's 'Let
%% it Crash' philosophy; however, in this case we should explicitly
%% prevent a situation that will crash Erlang's runtime engine
fib(N) when N  err_neg_val;
%% If fib/1 is passed an integer less than 3, then return 1
%% The preceding two function signatures handle all cases where N  1;
%% For all other values, call the private function fib_int/3 to perform
%% the calculation
fib(N) -> fib_int(N, 0, 1).
%% ---------------------------------------------------------------------
%% Private API
%% ---------------------------------------------------------------------
%% If fib_int/3 receives a 1 as its first argument, then we're done, so
%% return the value in argument B.  Since we are not interested in the
%% value of the second argument, we denote this using _ to indicate a
%% "don't care" value
fib_int(1, _, B) -> B;
%% For all other argument combinations, recursively call fib_int/3
%% where each call does the following:
%%  - decrement counter N
%%  - Take the previous fibonacci value in argument B and pass it as
%%    argument A
%%  - Calculate the value of the current fibonacci number and pass it
%%    as argument B
fib_int(N, A, B) -> fib_int(N-1, B, A+B).
Chương trình tương tự mà không có nhận xét giải thích:
-module(series).
-export(fib/1).
fib(0) -> 0;
fib(N) when N  err_neg_val;
fib(N) when N  1;
fib(N) -> fib_int(N, 0, 1).
fib_int(1, _, B) -> B;
fib_int(N, A, B) -> fib_int(N-1, B, A+B).

**Quicksort**
Quicksort trong Erlang, sử dụng danh sách hiểu:
%% qsort:qsort(List)
%% Sort a list of items
-module(qsort).     % This is the file 'qsort.erl'
-export(qsort/1). % A function 'qsort' with 1 parameter is exported (no type, no name)
qsort() -> ; % If the list  is empty, return an empty list (nothing to sort)
qsort(Rest) ->
% Compose recursively a list with 'Front' for all elements that should be before 'Pivot'
% then 'Pivot' then 'Back' for all elements that should be after 'Pivot'
qsort( Front = Pivot).
Ví dụ trên gọi đệ quy hàm qsort cho đến khi không còn gì để sắp xếp. Biểu thức Front 
Front  là một danh sách hiểu, nghĩa là "Xây dựng một danh sách các phần tử Front sao cho Front là một phần tử của Rest, và Front nhỏ hơn Pivot." ++ là toán tử nối danh sách.
Hàm so sánh có thể được sử dụng cho các cấu trúc phức tạp hơn để dễ đọc.
Đoạn code sau sẽ sắp xếp danh sách theo độ dài:
% This is file 'listsort.erl' (the compiler is made this way)
-module(listsort).
% Export 'by_length' with 1 parameter (don't care about the type and name)
-export(by_length/1).
by_length(Lists) -> % Use 'qsort/2' and provides an anonymous function as a parameter
qsort(Lists, fun(A,B) -> length(A)  ; % If list is empty, return an empty list (ignore the second parameter)
qsort(Rest, Smaller) ->
% Partition list with 'Smaller' elements in front of 'Pivot' and not-'Smaller' elements
% after 'Pivot' and sort the sublists.
qsort(X 
X Một Pivot lấy từ phần tử đầu tiên sẽ được cấp cho qsort() và phần còn lại của Lists được đặt tên là Rest. Lưu ý rằng biểu thứcX 
X không khác gì biểu thức dưới đây về hình thứcFront 
Front ngoại trừ việc sử dụng hàm so sánh trong phần cuối. Biểu thức trên có thể diễn đạt là "Xây dựng danh sách các phần tử X sao cho X là một phần tử của Rest, và Smaller thì đúng", với Smaller được định nghĩa trước đó là:fun(A,B) -> length(A) Hàm ẩn danh được đặt tên là Smaller trong danh sách tham số của định nghĩa thứ hai của qsort để nó có thể được tham chiếu bởi tên đó trong hàm đó. Nó không được đặt tên trong định nghĩa đầu tiên của qsort.

**Kiểu dữ liệu**
Erlang có 8 kiểu dữ liệu cơ bản:- Integers:- Atoms:- Floats- References- Binaries- Pids- Ports- Funs
3 kiểu dữ liệu phức hợp:- Tuples- Lists- Maps
và 2 Cú pháp đặc biệt được cung cấp:- Strings- Records

**Tham khảo**

**Đọc thêm**
 archive-date=ngày 23 tháng 3 năm 2015 - pages= 6–1 -  Early history of Erlang date=2019-08-29  by Bjarne Däcker
*pages=152–163

**Liên kết ngoài**
  Danh sách các phiên bản-  White paper
Thể loại:Erlang
Thể loại:Ngôn ngữ lập trình
Thể loại:Ngôn ngữ lập trình đồng thời
Thể loại:Ngôn ngữ lập trình khai báo
Thể loại:Ngôn ngữ lập trình được nhập động
Thể loại:Ericsson
Thể loại:Đã từng là phần mềm độc quyền
Thể loại:Ngôn ngữ hàm
Thể loại:Ngôn ngữ lập trình đối sánh mẫu
Thể loại:Ngôn ngữ lập trình động
Thể loại:Phần mềm tự do đa nền tảng
Thể loại:Họ ngôn ngữ lập trình Smalltalk