Docstoc

erlang

Document Sample
erlang Powered By Docstoc
					              Industrial Use of a
              Functional Language


              Thomas Arts
              Ericsson
              Computer Science Laboratory
              Stockholm, Sweden

              thomas@cslab.ericsson.se
              http://www.ericsson.se/cslab/~thomas
Thomas Arts
              Telecom industry

              • Switches, routers,
                base-stations
              • Networks
              • Mobile telephones




Thomas Arts
              Computer Science
              Laboratory

              • Founded 1983
              • Research on implementation tools,
              methods and techniques for
              telecommunication applications
              • Intermediate between universities
              and Ericsson product units


Thomas Arts
              Telecom requirements

              Requirements of telecom software

              • Concurrency
              • Distribution
              • Soft real-time
              • Robust
              • Non-stop system
              • External interfaces
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
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


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




Thomas Arts
              Erlang
              sequential program

              -module(math).
              -export([fac/1]).

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



Thomas Arts
              Erlang
              datatypes


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

Thomas Arts
              Erlang
              datatypes


              • dynamically typed language
              • poor mechanism to build your own
              datatypes




Thomas Arts
              Erlang
              control structures


              Matching

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


              Guards
              f(....) when guard -> ...

              If
              f(X) ->
                if guard1 -> ...;
                   guard2 -> ...
                end
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)]


Thomas Arts
              Erlang
              control structures


              Naming of objects/data
              f(X) ->
                 Dev = update_device(X),
                 {Date,Time} = now(),
                 h({Dev,Date}).




Thomas Arts
              Erlang
              control structures


              Sequence
              f(X) ->
                action1(X),
                action2(X);
                                   side-effects
              update(X) ->
                log(X,”myfile”), new(X).

Thomas Arts
              Erlang
              control - concurrency/distribution


              Creating a process
              Pid =
              spawn(F,[Arg1,...,ArgN]);

                            spawn(F,Args);
                        B = P2


                 P1                          P2

                      F(Arg1,...,ArgN)
Thomas Arts
              Erlang
              control - concurrency/distribution


              Sending messages
              Pid ! Message;


                      B!{self(),hej};

                          {P1,hej}
                 P1                        P2
                                                {P1,hej}



Thomas Arts
              Erlang
              control - concurrency/distribution


              Receiving messages
              receive
                Pattern -> ...;
              end;


                 P1                            P2
                                                    {P1,hej}
                    receive
                        {From,Msg} ->
                              ! {ok,hej}
                          P1 From ! {ok,Msg}
Thomas Arts
                    end
              Erlang
              changing code in running system

              loop(F) ->                             P0
                receive
               loop(F) ->
                  {change,G} ->
                 receive
                     loop(G);
                   {exec,Pid,Arg} ->
                  {exec,Pid,Arg} ->
                      Pid!F(Arg),
                     Pid!F(Arg),
                      loop(F)
                     loop(F)
                 end;
                end;

                                              {exec,self(),15},
                                       P0 =! F(15),
                                       N
                        P1             N = receive
                                               Answer ->
                                                  Answer
                                            end,

Thomas Arts
              Erlang
              fault tolerance

                         Processes can be linked to each o

                     PidA                 PidB



              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).
Thomas Arts
              Erlang
              fault tolerance


               When a process terminates, an exit
               signal is sent to all processes the
                      process is linked to:

                     PidA                 PidB




              A process can terminate normally, due to a run-
                time error, or when explicitly ordered to do so.
Thomas Arts
              Erlang
              fault tolerance

               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).



    PidA      PidB
              PidB          PidC            PidD           PidE


Thomas Arts
               Erlang
               fault tolerance

                 A process can terminate itself using
                exit(Reason). This will cause exit
                   signals with termination reason
                       Reason to be emitted.



                      error                 error
              PidA               PidB               PidC


                              exit(error)
Thomas Arts
               Erlang
               fault tolerance

                 A process can explicitly send an
                exit signal to another process using
                     exit(Pid, Reason):
                                      error
                           PidA                  PidB

                   exit(PidB, error)


              • The calling process is not affected.
              • The processes do not need to be linked.
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.

Thomas Arts
              Erlang
              fault tolerance

               PidC terminates with reason error,
                     PidD is trapping exits:

              PidB terminates, propagating the exit signal.
              PidD will receive an exit message
                     {'EXIT', PidC, error}.


                      error          error
     PidA
     PidA     PidB
              PidB            PidC           PidD         PidE


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




Thomas Arts
              Erlang
              fault tolerance

              supervision trees and restart strategies



                 P1    P2   P3    P1    P4    P3




                 P1    P2   P3    P4     P5   P6




Thomas Arts
              Erlang
              component based development

              recognize frequently occurring
              patterns and transfer them into
              standard components.

              • faster development
              • uniform code (maintenance)
              • less errors


Thomas Arts
              Erlang

              Developed with the application of the
              language constantly in mind

              Practical usability more priority than
              purity




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

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
Thomas Arts
              Erlang is used

              The success of the language in
              industry is due to

              • Language features
              • Support and libraries
              • Design patterns / architectures


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




Thomas Arts
                    Erlang

              The functional language
                    for industry




Thomas Arts

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:12
posted:9/8/2011
language:English
pages:35