1. Thomas Arts Industrial Use of a Functional Language Thomas Arts Ericsson Computer Science Laboratory Stockholm, Sweden thomas@cslab.ericsson.se http://www.ericsson.se/cslab/~thomas

2. Thomas Arts Telecom industry Switches, routers, base-stations Networks Mobile telephones

3. Thomas Arts Computer Science Laboratory Founded 1983 Research on implementation tools, methods and techniques for telecommunication applications Intermediate between universities and Ericsson product units

4. Thomas Arts Telecom requirements Requirements of telecom software Concurrency Distribution Soft real-time Robust Non-stop system External interfaces

5. Thomas Arts A good language? Experiments in the 80s with Ada, C, ML, CML, Prolog... large programs (million lines) change code in running system fast message passing low memory overhead no memory fragmentation/leaks recover from errors

6. Thomas Arts Erlang/OTP A functional language successfully used for programming large real- time control systems. OTP is the set of libraries that is used with Erlang for product development

7. Thomas Arts Erlang/OTP Erlang/OTP develop/maintenance Erlang consultancy & courses Erlang used many systems, e.g. ATM switch and new GSM network (GPRS) Erlang Open Source

8. Erlang sequential program Thomas Arts -module(math). -export([fac/1]). fac(N) when N>0 -> N*fac(N-1); fac(N)-> 1.

9. Thomas Arts Erlang datatypes atoms ( true,foo,’Hello’ ) numbers ( 1212864187154 ) floats ( 3.141592 ) tuples ( {a,123} ) lists ( [1,123,2,56] ) process identifiers...

10. Thomas Arts Erlang datatypes dynamically typed language poor mechanism to build your own datatypes

11. Thomas Arts Erlang control structures Matching case X of {ok,List} -> hd(List); {resend,Data} -> submit; error -> exit(error); _ -> retry(X) end

12. Thomas Arts Erlang control structures Guards f(....) when guard ->... If f(X) -> if guard1 ->...; guard2 ->... end

13. Thomas Arts Erlang control structures Higher order functions f(F,X) -> F(X); map(F,[1,2,3,4]). List comprehensions [ X || {X,Y}<-Set, guard(X)]

14. Thomas Arts Erlang control structures Naming of objects/data f(X) -> Dev = update_device(X), {Date,Time} = now(), h({Dev,Date}).

15. Thomas Arts Erlang control structures Sequence f(X) -> action1(X), action2(X); update(X) -> log(X,”myfile”), new(X). side-effects

16. Thomas Arts Erlang control - concurrency/distribution Creating a process Pid = spawn(F,[Arg1,...,ArgN]); P1P2 B = spawn(F,Args); P2 F(Arg1,...,ArgN)

17. Thomas Arts Erlang control - concurrency/distribution Sending messages Pid ! Message; P1P2 B!{self(),hej}; {P1,hej}

18. Thomas Arts Erlang control - concurrency/distribution Receiving messages receive Pattern ->...; end; P1P2 {P1,hej} receive {From,Msg} -> From ! {ok,Msg} end P1 ! {ok,hej}

19. Thomas Arts Erlang changing code in running system P0 loop(F) -> receive {exec,Pid,Arg} -> Pid!F(Arg), loop(F) end; P1 N = F(15), P0 ! {exec,self(),15}, N = receive Answer -> Answer end, loop(F) -> receive {change,G} -> loop(G); {exec,Pid,Arg} -> Pid!F(Arg), loop(F) end;

20. Thomas Arts Erlang fault tolerance Processes can be linked to each other: PidAPidB Links are created by using either: link(Pid), or spawn_link(Module, Function, Args) Links are bi-directional. They can be removed using unlink(Pid).

21. Thomas Arts Erlang fault tolerance When a process terminates, an exit signal is sent to all processes the process is linked to: PidAPidBPidA A process can terminate normally, due to a run- time error, or when explicitly ordered to do so.

22. Thomas Arts Erlang fault tolerance PidCPidDPidEPidAPidB PidD If a process terminates abnormally, the emitted exit signal will (by default) cause the recipient to terminate: The termination reason in the transmitted exit signals will be the same as in the received one (the exit signal is propagated).

23. Thomas Arts Erlang fault tolerance exit(error) PidBPidC error PidA error A process can terminate itself using exit(Reason). This will cause exit signals with termination reason Reason to be emitted.

24. Thomas Arts Erlang fault tolerance A process can explicitly send an exit signal to another process using exit(Pid, Reason) : exit(PidB, error) PidBPidA error The calling process is not affected. The processes do not need to be linked.

25. Thomas Arts Erlang fault tolerance A process can trap exit signals using: process_flag(trap_exit, true). Incoming exit signals will be transformed into messages of the form: {'EXIT', Pid, Reason} These exit messages are delivered to the process mailbox in the normal way.

26. Thomas Arts Erlang fault tolerance PidC terminates with reason error, PidD is trapping exits: PidCPidDPidEPidAPidB error PidBPidA PidB terminates, propagating the exit signal. PidD will receive an exit message {'EXIT', PidC, error}.

27. Thomas Arts Erlang fault tolerance Robust systems can be made by layering.

28. Thomas Arts Erlang fault tolerance supervision trees and restart strategies P1 P2P3 P1 P4P3 P6P5 P1 P2P3 P4

29. Thomas Arts Erlang component based development recognize frequently occurring patterns and transfer them into standard components. faster development uniform code (maintenance) less errors

30. Thomas Arts Erlang Developed with the application of the language constantly in mind Practical usability more priority than purity

31. Thomas Arts Erlang is used AXD 301, scalable ATM switch (up to 160 GB/sec) four years work more than 500,000 lines of Erlang several hundreds of programmers

32. Thomas Arts Erlang is used GPRS: next generation GSM network. Eigth times faster internet access in mobile phones always connected development in three countries, hundreds of people

33. Thomas Arts Erlang is used The success of the language in industry is due to Language features Support and libraries Design patterns / architectures

34. Thomas Arts Erlang is used Become a user yourself! passive: make a phonecall active: download Erlang for free over 300 downloads per month

35. Thomas Arts Erlang The functional language for industry