ERLANG THE WORLD IS PARALLEL.

Picture: http://www.cs.purdue.edu/homes/jv/events/TiC06/pr.jpg

the world is parallel.

If we want to write programs that behave as other objects behave in the real world, then these programs will have a concurrent structure.

Use a language that was designed for writing concurrent applications, and development becomes a lot easier.

Erlang programs model how we think and interact.

Joe Armstrong

Agenda   What we cover   What we don’t cover   You used Erlang to write what?   History   OTP   The language   Concurrency   Distribution   Hot code swapping   Compile and run   Development environments   Various tidbits

Note and forgive that…

  This is an Erlang beginner trying to give you an overview

  I haven’t used Erlang for a while

What we cover

  What is it good for?   Glance at functional programming   Basic syntax and structure   Erlang’s main features   Basic tools to get you started   Info on where to find more

material

What we DON’T cover

  How to install Erlang   A (blog) tutorial in 15 minutes   Language reference   How to write programs using a

functional programming language   How to parallelize programs   How to distribute algorithms   How to use the Open Telecom Platform   Tons of example code

Therefore

  Read the book

You used Erlang to write what?

http://www.cio.com/article/191000/You_Used_Ruby_to_Write_WHAT_ http://www.zedshaw.com/

You used Erlang to write what?

  Systems/Applications that are:  Concurrent  Parallel (SMP)  Distributed  Fault tolerant  Dynamically upgradable

History

  Created by the Computer Science Laboratory at Ellemtel (now Ericsson AB) around 1990

  Named after A. K. Erlang (not Ericsson Language)

  Licensed Version (Ericsson http://www.erlang.se)

  Released as open source in 1998 under EPL (http://www.erlang.org)

Ref: wikipedia.org

Open Telecom Platform

  Middleware   Similar to J2EE Container (JBoss, GlassFish,

IBM WebSphere, BEA Weblogic)   Coding standards   Tools like web server, FTP server and CORBA

ORB are included in OTP   Licensed under Erlang Public License (EPL)

OTP

Source: http://www.ericsson.com/technology/opensource/erlang/index.shtml Picture: http://www.ericsson.com/technology/opensource/images/erlang.gif

Erlang in use

  Ejabberd (http://www.ejabberd.im)   Yaws (http://yaws.hyber.org/)   CouchDB (

http://incubator.apache.org/couchdb)   Ericsson products AXD301 (ATM switch),

SGSN, GGSN (GPRS nodes) according to http://www.erlang.se/productinfo/index.shtml

The language

  Functional programming language!   (little) to no side effects  Single assignment variables  Pattern matching  Higher-order functions  Recursion  No objects  Haskell, Lisp, ML, F#, Scheme

So don’t think imperative!

  Don’t think  Java  C#  C  PHP  Etc.

Think

Functional!

Don’t think

Procedural

Think

Recursive!

Don’t think

Loopy

Let‘s get started

Picture: http://www.wampower.com/images/wam%20pics/getting%20started/getting_started.jpg

Let’s get started

  Start interactive shell called erl and try things out (like irb in Ruby)

  ^G q to quit the shell   % indicates a comment   . terminates a statement

Files, modules and functions

  Example on next slide   Module “geometry” would be defined in

“geometry.erl”   Export the functions you want to be public   Don’t forget to specify the arity, number of params

in function’s signature (e.g area/1)   Compile modules within erl before using them

c(module_name)   Use : to access a module’s public functions =>

lists:filter()   erl –man module_name for man page => erl -man

lists

Variables

  Start with an uppercase letter   Single assignment like in Prolog so X = X + 1 is a

no go   Integers

 No limitation for integers e.g. faculty of 2000 returns valid result (Try that in Eiffel™)

  Floats  A division always returns a float   Limited in size (IEEE 754 64-bit)

  Strings: S = “world” (double quotes)

Atoms and Tuples

  Atoms  Represent non numerical constant values  Start with lowercase letter

  Tuples  Store a fixed number of items into a single entity  F = {name , isabella}  E = {woweffect, 10}  Person = {person,{height,10},{gender,male}}  Beauty = {beauty , F , E}

Lists

  Store variable numbers of things   Head and tail syntax   Define a list:

 Student_grades = [{john,c},{michael,b},{lolita,aplus},{joe,b}].

  Extract into head and tail   [Headval1,Headval2|Tailval] = Student_grades  Where Headval1 matches with the 1st element,

Headval2 with 2nd and Tailval with the rest   See erl –man lists

http://images.apple.com/downloads/dashboard/travel/images/traveltodolist_20070724165034.jpg

Functions -module(intro).

-export([main/0,factorial/1,some_other_function/0]).

% number in export statement defines arity of exported function

% only exported functions can be used from outside the module

main() -> io:format("The factorial of 5 is ~w ~n”,[factorial(5)]).

factorial(0) -> 1;

factorial(nonsense) -> "nonsense";

factorial(N) -> N*factorial(N-1).

% use comma to add statements together

some_other_function() -> T = private_module_function(10,20),

T + 11.

% this function is not available from outside the module

private_module_function(X,Y) -> X * Y.

Picture: http://casoilresource.lawr.ucdavis.edu/drupal/files/images/logistic-small.png

Anonymous functions (Funs)

http://image.guardian.co.uk/sys-images/Arts/Arts_/Pictures/2007/08/10/laugh460.jpg

Anonymous functions (Funs)

  Like in JavaScript, delegates in C#   Like regular functions but the word “end” defines the

end of the function. Still use a period to indicate end of line.

  Cubic = fun(X) -> X*X*X end.   Cubic(2) evaluates to 8.   Funs can be useful as arguments eg. inline

  lists:filter(fun(X) -> X > 10 end, [1,2,3,445,28,203]).   Returns [445,28,203]

  It is legal to pass a variable containing a Fun instead of defining it inline

  Funs can return Funs

List comprehensions

  Mostly shorter than funs, maps and filters   To triple every element using funs we could

write:  Lists:map(fun(N) -> 3*N end, L)

  Using list comprehensions   [ 3*N || N <- L]

  More complex forms are possible   [ {triple, 3*N} || N <- L]  According to the rules of pattern matching

Stuff left out to save time   Guards => Conditions

  f(X) when is_integer(X), X > 10 -> io:format(“X is greater than 10”).

  Predicates like is_integer()   Built-in functions like length(X)

  Records (for large tuples)   ETS / DTS   case and if Expressions   Exceptions (try catch syntax)   Built-in Functions (BIFs)

  http://www.erlang.org/doc/man/erlang.html   Macros

Picture: http://www.ourappraisal.com/xsites/Appraisers/centralilappraisal/content/uploadedFiles/refi_clock_ticking.jpg

Concurrency

  Processes belong to Erlang and not the operating system (User, not kernel space)

  Creating and destroying processes is very fast   Sending messages between processes is very

fast   Processes behave the same way on all operating

systems   We can have a large number of processes.   Processes share no memory and are completely

independent   The only way for processes to interact is through

message passing

Concurrency

  Concurrency primitives   spawn Pid = spawn(Fun)

  send Pid ! Message

  receive receive

Pattern 1 Expressions1;

Pattern 2 Expressions 2;

... end

Picture: http://www.spacecast.com/images/Shows/spawn_img1.jpg

Distribution

  Distributed Erlang  Programs are written to run on Erlang nodes  Spawning processes on any node is very easy  Message passing and error handling is the same as in

a non distributed environment (one single node).  The nodes run in a trusted environment (same LAN)  Make sure, you run the same codebase and erlang

version   Socket-Based Distribution

 Using TCP/IP Sockets  The Applications can run in a untrusted environment

Hot Code Swapping

Picture: http://www.firewebdesigns.com/images/fire_02.jpg

Hot Code Swapping

  Erlang supports change of code in a running system  Very cool for upgrading software

  Code for Module exist in two variants in the system  State Current  State Old

  OTP provides libraries for enhanced Code Swapping functionality

Multicore CPU’s

  Again, in Erlang, processes have no shared memory, so no mutexes, locks whatsoever

  Make sure, your program has a lot of processes   Avoid side effects (those that the language and

the runtime can’t prevent)   In fact, Erlang has shared data structures

(ETS,DETS). Better use Mnesia with transactions if you need a shared storage.  Mnesia is a distributed DBMS for Erlang   http://www.erlang.org/documentation/doc-5.0.1/lib/

mnesia-3.9.2/doc/index.html

Symmetric Muliprocessing with SMP Erlang   erl –smp +S N

 Where N specifies the number of schedulers to use

 A Scheduler is a complete virtual machine  Possibility to emulate a system with more CPU’s

  See previous slide for some requirements to parallelize a program

Compile and run

  Within erl shell  c(module_name)

  Compiler  erlc module_name.erl  erl –noshell –s module_name function_name –s

init stop   As an escript

#!/usr/bin/env escript main(_) ->

io:format("hello world~n").

  Automate things using build tools like make, ant etc.

Development environment

  http://www.erlang.org/download.html to install environment

  Erlang mode for emacs   http://www.erlang.org/doc/apps/tools/

erlang_mode_chapter.html   Erlang bundle for TextMate

  http://macromates.com/svn/Bundles/trunk/Bundles/Erlang.tmbundle/

  Erlybird for Netbeans   http://sourceforge.net/projects/erlybird/

  Erlide   http://erlide.sourceforge.net/

Various tidbits   Documentation generator called Edoc which is similar to Javadoc™

  http://www.erlang.org/doc/apps/edoc/index.html   When things go wrong, consult the crash dump.

  webtool:start().   Go to http://localhost:8888

  Unit testing framework called EUnit making heavy use of macros for the assertions   http://svn.process-one.net/contribs/trunk/eunit/doc/overview-

summary.html   ErlyWeb, a web framework written in Erlang

  http://yarivsblog.com   The Dialyzer, a static analysis tool to identify problems with program

code   http://www.it.uu.se/research/group/hipe/dialyzer/

Where to find help?

  Excellent documentation and examples on erlang.org  http://www.erlang.org/starting.html  http://www.erlang.org/doc.html  http://www.erlang.org/doc/reference_manual/

part_frame.html  http://www.erlang.org/examples.html

  Joe Armstrongs home page  http://www.sics.se/~joe/

  Consult erl –man module_name

Further reading

  Open Source Erlang   http://www.erlang.org

  The High-Performance Erlang Project   http://www.it.uu.se/research/group/hipe/

  Trapexit, an Erlang community site   http://www.trapexit.org/

  Comprehensive Erlang Archive Network   http://cean.process-one.net/

  Erlang style concurreny   Article about concurrency explaining important topics using

Java syntax to explain things   http://www.defmacro.org/ramblings/concurrency.html

Further reading

  Programming Erlang, Software for a Concurrent World, Joe Armstrong (Pragmatic Bookshelf, 2007), ISBN 978-1-934356-00-5, Available in print and PDF

  Erlang: The Movie ;-)  http://video.google.com/videoplay?

docid=-5830318882717959520