1. Concurrent Functional Programming with Erlang and OTP (Open Telecom Platform)
Bjarne Däcker Computer Science Laboratory
Ericsson Utvecklings AB
Acknowledgements
Thomas Arts
Hans Nilsson
Torbjörn Keisu
Ulf Wiger
The purpose of this presentation is to show how the AXD 301 project successfully solved the inherent challenges in building today’s complex datacom products.
The AXD 301 ATM switch ...

2. The setting 1995 PC Week Study of software projects:
16% successful
53% operational (but less than successful)
31% cancelled
Butler Group 1997 on large software projects
5 out of 6 large projects fail
In >$300M companies, 9 out of 10 large projects fail
How to approach this?
Use high-level modeling tools & generate code?
Raise the level of programming language?
Fight all causes for project failure!

3. Switches, routers, base-stations Networks Mobile telephones
Telecom industry
Switches, routers,
base-stations
Networks
Mobile telephones

4. Requirements on a Programming Technology for Telecommunication Switching Systems
Massive concurrency
Soft realtime
Distribution
Interaction with hardware
Very large software systems
Complex functionality
Continuous operation for many years
Software maintenance without stopping the system
Stringent quality and reliability requirements
Fault tolerance errors

5. No language well suited
History of Erlang
No language well suited
for telecom systems
development
1984:
Ericsson
Computer
Science Lab
formed
1998:
Open Source
Erlang
1991:
First fast
implementation
1987:
Early Erlang
Prototype projects :
Experiments
programming
POTS with
several languages
1996:
Open Telecom Platform
(research on verification...)
1995:
Several
new projects
1993:
Distributed
Erlang

6. The Ancestry of Erlang
Concurrent systems programming languages like Ada, Modula or Chill
Functional programming languages like ML or Miranda
Concurrent functional programming language Erlang

7. Functional programming language High abstraction level
Erlang Highlights
Functional programming language
High abstraction level
Pattern matching
Concise readable programs
Declarative
Concurrency
Soft real-time
Robustness
Distribution
Hot code loading
External interfaces
Portability

8. Basics - Factorial function
Erlang Example
Basics - Factorial function
n! = 1
n*(n-1)!
n = 0
n 1
Definition
-module(ex1).
-export([factorial/1]).
factorial(0) -> 1;
factorial(N) when N >= 1 ->
N * factorial(N-1).
Implementation
Eshell V (abort with ^G)
1> c(ex1).
{ok,ex1}
2> ex1:factorial(6).
720

9. taken from the list Tail,
Erlang Example
A few very high-level constructs - QuickSort
-module(ex2).
-export([qsort/1]).
qsort([Head|Tail]) ->
First = qsort([X || X <- Tail, X =< Head]),
Last = qsort([Y || Y <- Tail, Y > Head]),
First ++ [Head|Last];
qsort([]) ->
[].
"all objects Y
taken from the list Tail,
where Y > Head"
Eshell V (abort with ^G)
1> c(ex2).
{ok,ex2}
2> ex2:qsort([7,5,3,8,1]).
[1,3,5,7,8]

10. Light-weight processes
Erlang Highlights
Either transparent or
explicit concurrency
Light-weight processes
Highly scalable
Declarative
Concurrency
Soft real-time
Robustness
Distribution
Hot code loading
External interfaces
Portability

11. Creating a new process using spawn
Erlang Example
Creating a new process using spawn
-module(ex3).
-export([activity/3]).
activity(Name,Pos,Size) ->
…………
activity(Joe,75,1024)
Pid = spawn(ex3,activity,[Joe,75,1024])

12. Processes communicate by asynchronous message passing
Erlang Example
Processes communicate by asynchronous
message passing
Pid ! {data,12,13}
receive
{start} -> ………
{stop} -> ………
{data,X,Y} -> ………
end
receive
{start} -> ………
{stop} -> ………
{data,X,Y} -> ………
end

13. Concurrency - Finite State Machine
Erlang Example
Concurrency - Finite State Machine
Selective receive
ringing_a(A, B) ->
receive
{A, on_hook} ->
back_to_idle(A, B);
{B, answered} ->
A ! {stop_tone, ring},
switch ! {connect, A, B},
conversation_a(A, B)
after >
back_to_idle(A, B)
end.
back_to_idle(A, B) ->
B ! terminate,
idle(A).
Asynchronous send
Optional timeout

14. Per-process garbage collection
Erlang Highlights
Response times in the
order of milliseconds
Per-process garbage collection
Declarative
Concurrency
Soft real-time
Robustness
Distribution
Hot code loading
External interfaces
Portability

15. Supervision hierarchies "Program for the correct case"
Erlang Highlights
Simple and consistent
error recovery
Supervision hierarchies
"Program for the correct case"
Declarative
Concurrency
Soft real-time
Robustness
Distribution
Hot code loading
External interfaces
Portability

16. Cooperating processes may be linked together
Erlang Example
Cooperating processes may be linked together
using
spawn_link(…,…,…) or
link(Pid)

17. Erlang Example
When a process terminates, an exit signal is sent to all linked processes
… and the termination is propagated

18. Erlang Example Exit signals can be trapped and received as messages
{‘EXIT’,Pid,...} -> ...
end

19. Erlang Example Robust systems can be built by layering “Supervisors”
“Workers”

20. Explicit or transparent distribution Network-aware runtime system
Erlang Highlights
Explicit or transparent distribution
Network-aware runtime system
Declarative
Concurrency
Soft real-time
Robustness
Distribution
Hot code loading
External interfaces
Portability

21. Transparent Distribution
B ! Msg
C ! Msg
Erlang Run-Time System
Erlang Run-Time System
network

22. Simple RPC {rex, Node} ! {self(), {apply, M, F, A}}, receive
{rex, Node, What} -> What
end
{rex, Node} ! {self(), {apply, M, F, A}},
receive
{rex, Node, What} -> What
end
{rex, Node} ! {self(), {apply, M, F, A}},
receive
{rex, Node, What} -> What
end
loop() ->
receive
{From, {apply, M, F, A}} ->
Answer = apply(M, F, A),
From ! {rex, node(), Answer}
loop();
_Other -> loop()
end.
loop() ->
receive
{From, {apply, M, F, A}} ->
Answer = apply(M, F, A),
From ! {rex, node(), Answer}
loop();
_Other -> loop()
end.
loop() ->
receive
{From, {apply, M, F, A}} ->
Answer = apply(M, F, A),
From ! {rex, node(), Answer}
loop();
_Other -> loop()
end.
loop() ->
receive
{From, {apply, M, F, A}} ->
Answer = apply(M, F, A),
From ! {rex, node(), Answer}
loop();
_Other -> loop()
end.
This is the essential loop needed for an RPC server.
The server receives requests from clients, uses apply to evaluate the requests and then returns the answer to the originator.
This is a simplified solution where no error handling is done.
The BIF node/0 returns the node name.

23. Enables non-stop operation
Erlang Highlights
Easily change code in a
running system
Enables non-stop operation
Simplifies testing
Declarative
Concurrency
Soft real-time
Robustness
Distribution
Hot code loading
External interfaces
Portability

24. Erlang Example
Version 1
Version 2

25. "Ports" to the outside world behave as Erlang processes
Erlang Highlights
"Ports" to the outside world
behave as Erlang processes
Declarative
Concurrency
Soft real-time
Robustness
Distribution
Hot code loading
External interfaces
Portability

26. Erlang Example External process Port ! {self(), {command, [1,2,3]}}

27. Erlang Example External process receive {Port, {data, Info}} -> end

28. Supports heterogeneous
Erlang Highlights
Erlang runs on any UNIX,
Windows, VxWorks, ...
Supports heterogeneous
networks
Declarative
Concurrency
Soft real-time
Robustness
Distribution
Hot code loading
External interfaces
Portability

29. Erlang Run-Time System
Systems Overview
Applications written
in Erlang
Applications
written in C,
C++ or Java
OTP Components
Standard Libraries
Erlang Run-Time System
Hardware and Operating System

30. Erlang/OTP Open Telecom Platform Middleware for Erlang development
Designed for fault tolerance and portability
Behaviors: A formalization of design patterns
Components
Error handling, reporting and logging
Mnesia, distributed real-time database management system
CORBA
IDL Compiler, Java & C Interface Support
HTTP Server
SNMP Agent
...

31. OTP Behaviors "A formalization of design patterns"
A behavior is a framework + generic code to solve a common problem
Each behavior has built-in support for debugging and software upgrade
Makes it easier to reason about the behavior of a program
Examples of OTP behaviors
application defines how an application is implemented
supervisor used to write fault-tolerant supervision trees
gen_server for writing client-server applications
gen_event for writing event handlers
gen_fsm for finite state machine programming

32. The standard textbook
Joe Armstrong, Robert Virding, Claes Wikström and Mike Williams, Concurrent Programming in Erlang, Prentice Hall, 1996, 2nd edition, ISBN X

33. Interesting web pages Open source Erlang www.erlang.org
Commercial Erlang
French Erlang site

34. Courses/year (10-15 pupils/course)

35. Requests/month to www.erlang.org

36. Downloads/month from www.erlang.org

37. More than just technology...
AXD 301: A Telephony-Class, scalable ( GBps) ATM switch designed from scratch in less than 3 years
AXD 301 Success factors:
Highly pragmatic, holistic approach
Competent organisation
Efficient process
Excellent technology (e.g. Erlang/OTP)
More than just technology...
Consider all factors together from the start
Erlang was a perfect match for our approach

38. Migrating today's vertical networks
AXD 301 in the marketplace
ENGINE:
Migrating today's vertical networks
into a single multi-service backbone
Central component in Ericsson's ENGINE offering
Several major operators
British Telecom
Vodaphone
Worldcom
Telia
Diveo
...

39. Briefly about the term Carrier-Class
To us, "Carrier-Class", "Telephony-Class" and "Telecom Profile" are synonymous
The quality we've come to expect from public telephony networks
The trend towards multimedia services requires Carrier-Class in more systems
More than just duplication of hardware:
Fault-tolerant software
In-service hardware expansion
In-service software upgrade
Load tolerance
Flexibility (frequent changes + long service life)
Target: 99,999% ("five nines") availability, including planned outages
There's no such thing
as "almost Carrier-Class"!

40. Telecom-Class System Architecture
simple wire-speed logic
complex soft-real-time logic
Line Termination
ATM Termination
Control Processors CP IO
ATM
ATB
Mandatory Mated Processor Pair
Switch Core CP IO CE
ATB FR
ATB CP IO
Optional Processors
Server Device
L3F
ATB CP IO
Device Processor
on Each Board
Clock &
Synchronization

41. Programming languages (control system)
Erlang: ca 1 million lines of code
Nearly all the complex control logic
Operation & Maintenance
Web server and runtime HTML/JavaScript generation
C/C++: ca 500k lines of code
Third party software
Low-level protocol drivers
Device drivers
Java: ca 13k lines of code
Operator GUI applets

42. Experiences from AXD 301 SW Design
Using Erlang in Complex Systems
Fits very well with the incremental design method
High programmer satisfaction
Outstanding support for robustness and concurrency
Very few side-effects  easier to add/change single components
Small directed teams can achieve impressive results
Productivity estimates
Similar line/hour programmer productivity
4-10 fewer lines of source code (compared to C/C++, Java, PLEX)
4-10x higher programmer productivity
Similar number of faults per 1000 lines of source code
4-10x higher quality

43. Functional Requirements
Use cases (in telecom “traffic cases”)
User interfaces
...
Non-functional Requirements
Code updating without interrupting the service
Distribution over several processors
Automatic handover upon error
Limited restart time
The non-functional requirements are often much trickier to handle and require technology bottom-up rather than analysis top-down.

44. Efficient Program Development
Requirements
Interaction with the real environment
Powerful and appropriate abstraction mechanisms
Efficient implementation
Useful tools
Ideas
Prototyping
Productification

45. A Simple Erlang-XML Document
{‘home.page’, [{title, “My Home Page”}],
[{title, “Welcome to My Home Page”},
{text,
[{para,
“Sorry, this home page is still under ”
“construction. Please come back soon!”} ]}
]}.
Erlang
<?xml version=“1.0”?>
<home.page title=“My Home Page”>
<title>
Welcome to My Home Page
</title>
<text>
<para>
Sorry, this home page is still under
construction. Please come back soon!
</para>
</text>
</home.page>
Almost equivalent

46. www.erlang.org www.erlang.se Erlang Summary Declarative Concurrency
Compact code
Concurrency
Light-weight processes
Message passing
Soft real-time
Robustness
Process supervision
Error trapping
Distribution
Hot code loading
External interfaces
To hardware and other languages
Portability

47. The Research Continues ...
HiPE - High Performance Erlang (Uppsala, Astec)
ETOS - Erlang to Scheme (Montréal)
Erlang Verification (SICS, Astec)
Type System (Glasgow)
“Safe” Erlang (Canberra)
Specification Techniques (Aachen)
Erlang Processor (Ericsson CADLab)
...

48. Erlang User Conference 2000
Hurray !!!

49. Welcome to the next EUC September 27, 2001 Älvsjö. Stockholm
Combined with IFL - International
Workshop on the Implementation
of Functional Languages
September 24-26, 2001
Älvsjö. Stockholm