Erlang History
45
Transcript of Erlang History
2/45
Plan BeginningsWhat is Erlang?Pre historyInnovationsPhilosophySpreading the languageFuture
3/45
Beginnings1985 - “find better ways of programming telephony” SPOTS - LOTS SPOTS = SPC for POTS SPC = Stored Program Control (“computer controlled”) POTS = Plain Ordinary Telephone Service
Write telephony in many different languages
No “plan” to make another programming language
4/45
What is Erlang?
5/45
What is Erlang?- Concurrent (processes belong to Language – NOT OS)- Very light-weight concurrency (lighter than threads)- “Share nothing” process semantics- Pure asynchronous message passing- Core language is a simple dynamically typed FPL- Non-pure extensions (ets) for implementing databases.- Mechanisms for in-service code upgrade- Large set of libraries (OTP) (Unix <-> C <==> OTP <-> Erlang)
6/45
Pre historyAXE – programmed in PLEX
PLEX Programming language for exchanges) Proprietary blocks (processes) and signals in-service code upgrade
Eri Pascal
7/45
- Handling a very large number of concurrent activities- Actions to be performed at a certain point of time or within certain time- Systems distributed over several computers- Interaction with hardware- Very large software systems- Complex functionality such as feature interaction- Continuous operation over several years- Software maintenance (reconfiguration, etc.) without stopping the system- Stringent quality and reliability requirements- Fault tolerance both to hardware failures and software errors
Requirements
8/45
1985 - 1998
9/45
1985 - 1989Erlang is born
- Programming POTS/LOTS/DOTS- A Smalltalk model of POTS- A telephony algebra (math)- A Prolog interpretor for the telephony algebra- I add processes to prolog- Prolog is too powerful (backtracking)- Deterministic prolog with processes- “Erlang” !!!- ...- Compiled to JAM code-
10/45
Phoning Philosopher's
Armstrong, Elshiewy, Virding (1986)Conclusion – Concurrent Logic programming with channel communication
11/45
The Telephony Algebra -(1985)
idle(N) means the subscriber N is idle on(N) means subscribed N in on hook ...
+t(A, dial_tone) means add a dial tone to A process(A, f) :- on(A), idle(A), +t(A,dial-tone), +d(A, []), -idle(A), +of(A)
Using this notation, POTS could be described using fifteenrules. There was just one major problem: the notation only describedhow one telephone call should proceed. How could we do this forthousands of simultaneous calls?
12/45
The Prolog interpretor (1986)
version 1.06 dated1986-12-18
1.03 “lost in the mists of time”
13/45
The first Erlang operations manual (1986)
14/45
Teaching Erlang
Started as Prolog courses
(A pre powerpoint slide - 1986)
15/45
1988 – Interpreted Erlang
- 4 days for a complete re-write- 245 reductions/sec- semantics of language worked out- Robert Virding joins the “team”
16/45
Ways of working
- Light-weight committees- Total rewrite < 1 week- Language feature = one hacking session- Try it out on the users, keep the good stuff- Many different versions- Clear goal – we knew what we wanted to do but not how- Nobody knew what we were doing
17/45
1989 – The need for speed
ACS- Dunder - “we like the language but it's too slow” - must be 40 times faster
Mike Williams writes the emulator (in C)
Joe Armstrong writes the compiler
Robert Virding writes the libraries
18/45
fac(0) -> 1;fac(N) -> N * fac(N-1)
{info, fac, 1} {try_me_else, label1} {arg, 0} {getInt, 0} {pushInt, 1} ret label1: try_me_else_fail {arg, 0} dup {pushInt, 1} minus {callLocal, fac, 1} times ret
sys_sys.erl 18 dummysys_parse.erl 783 erlang parsersys_ari_parser.erl 147 parse arithmetic expressionssys_build.erl 272 build function call argumentssys_match.erl 253 match function head argumentssys_compile.erl 708 compiler main programsys_lists.erl 85 list handlingsys_dictionary.erl 82 dictionary handlersys_utils.erl 71 utilitiessys_asm.erl 419 assembler sys_tokenise.erl 413 tokeniser sys_parser_tools.erl 96 parser utilitiessys_load.erl 326 loadersys_opcodes.erl 128 opcode definitionssys_pp.erl 418 pretty printersys_scan.erl 252 scannersys_boot.erl 59 bootstrapsys_kernel.erl 9 kernel calls18 files 4544
An early JAM compiler (1989)
Like the WAM with added primitives forspawning processes and message passing
19/45
During development
Robert and I were convinced that one day we would have to add destructive operations to the language, but that we would wait until a problem that could not be solved with pure operations turned up.
This never happened
At first the implementation was the only documentation
The manual always lagged behind the implementation
Then when the language matured we decided it should be the other way around. This made life a lot easier.
We wrote the manual and it was “definitive” - not the code.
20/45
1989 - Clarity1989 (SETSS conference Bournemouth)
- Need 2 or more computers for fault-tolerance- If one computer crashes must continue on the other- Cannot share data over processor boundaries- Each computer must be “self contained”- Asynchronous message passing- Failures will occur
(Later these ideas reappear as “isolation” “let it crash”“share nothing” “pure message passing”)
(Implicit rejection of shared-memory systems, in favourof pure message passing systems)
21/45
Shared memory and
Fault toleranceis
Incredibly difficult
22/45
Sharing is the
property that
preventsfault tolerance
23/45
Chronology from 1989 onwards
1989 – JAM – language gets own syntax – things like receive change1990 – A reasonable efficient Erlang exists1991 – Distribution work starts 1993 – Prentice Hall Book – freezes many things Turbo Erlang (BEAM). Distribution
completed1995 – AXE-N collapses1997 – OTP started (a rewrite of BOS)1997? - Bit syntax and binaries added (for protocol programming ) ets for programming mnesia1998 – AXD301 announced – Erlang banned – open source Erlang2006 – SMP Erlang
24/45
1985 - 1998
25/45
What did we learn?
26/45
Innovations- bit syntax- link mechanism- non-defensive programming- pure message passing works
27/45
Bit Syntax - Pattern matching over bits
-define(IP_VERSION, 4).-define(IP_MIN_HDR_LEN, 5).
DgramSize = size(Dgram),case Dgram of <<?IP_VERSION:4, HLen:4, SrvcType:8, TotLen:16, ID:16, Flgs:3, FragOff:13, TTL:8, Proto:8, HdrChkSum:16, SrcIP:32, DestIP:32, RestDgram/binary>> when HLen>=5, 4*HLen=<DgramSize -> OptsLen = 4*(HLen - ?IP_MIN_HDR_LEN), <<Opts:OptsLen/binary,Data/binary>> = RestDgram, ...end.
unpack(<<Red:5,Green:6,Blue:5>>) -> ...
Due to Klacke(Claes Vikström)
(unpack Ipv4 datagram)
28/45
Links
A B
C
A is linked to BB is linked to C
If any process crashes anEXIT message is sent to the linked processes
This idea comes from the “C wire” in early telephones(ground the C wire to cancel the call)
Encourages “let it crash” programming
29/45
Supervision trees
(These are possible because of links)
30/45
“let it crash”
- We encourage a non defensive style of programming
- Use worker/supervisor model of programming
- Separation of issues between error detection and recovery and “doing the job” (enabled by light-weight processes, links and process isolation)
- This style of programming is not possible in a single threaded language
31/45
Pure message passing concurrency works
“share nothing” - copy everything programming works for many problems
- This is a surprise to lot's of people- Has it's roots in “ISS89”
32/45
Philosophy –explaining what we're doing
- Logic programming with concurrency (1986)- Declarative programming with concurrency- Functional programming with concurrency- Concurrency with a functional core- Interacting black boxes, governed by protocols where the protocols happen to be implemented in a functional language- Concurrency Oriented Programming (2002)
33/45
Concurrency Oriented Programming
● A style of programming where concurrency is used to structure the application● Large numbers of processes● Complete isolation of processes● No sharing of data● Location transparency● Pure message passing
My first message is that concurrency is best regarded as a program structuring principle”
Structured concurrent programming – Tony Hoare
Redmond, July 2001
34/45
What is COP?
● Large number of processes● Complete isolation between processes● Location transparency● No Sharing of data● Pure message passing systems
Machine
Process
Message
35/45
Erlang Style Concurrency
- Share nothing- Pure message passing- “Let it crash”
36/45
Spreading the language1986 – CSLab (Ericsson)1987 – Bollmora ACS/Dunder starts (First users) (results 1989)1998 – SETS 1989 (Bournemouth) – contact with John Unger Bellcore1990 – ISS90 – shown in public1992 – Concurrent Programming in Erlang (Prentice Hall)1993 – Erlang systems AB (“Uppsala master's student's”)1998 – Erlang banned in Ericsson Open-source Erlang Blutail2000 – Bluetail acquired by Alteon , subsequently Nortel2001 – Dot-com bubble crashes (This lays the seeds of half a dozen Erlang companies)2002-2004 – Staying alive - “survival of the fittest”2004-2007 – Resurgence2006 – SMP Erlang2007 - “Programming Erlang” (The Pragmatic Programmers) “Multicore” erlang works! (New products in Ericsson)
37/45
ISS 90
Erlang – the movie
38/45
User Conferences
User conferences held every year since 1994 (except 1996)
39/45
Does it
work?
40/45
Ericsson AXD301 (part of “Engine”) (1.1 million lines of Erlang)Ericsson GPRS systemAlteon (Nortel) SSL acceleratorAlteon (Nortel) SSL VPN Teba Bank (credit card system – South Africa)T-mobile SMS system (UK)Kreditor (Sweden)SynapseTail-fjabber.org /uses ejabberd)twitter (uses ejabberd)
Commercial Successes
41/45
The future
42/45
Q: Does Erlang run N times faster on an N-core multiprocessor?
A: Sometimes (often :-)
Q: Why?
A: No Mutable state + Concurrency
Erlang is great on multicores
43/45
Lessons Learnt- Message passing concurrency works The extra overhead of copying is unimportant- Isolation is the key property of the language- Processes belong to languages NOT OS's- Pure is fast (enables concurrency)- “share nothing” is fast enough- Don't compromise beauty for efficiency
44/45
AcknowledgementsTo Ericsson AB for their support
Bjarne Däcker – ex head of the CS LabThe Gang of four = (Mike Williams, Robert Virding, Claes Vikström + the author)
Kenneth Lundin and the OTP group at Ericsson
And a cast of hundreds ... (see the paper)
45/45
Questions
download Erlang fromhttp://www.erlang.org
