• Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
4,156
On Slideshare
0
From Embeds
0
Number of Embeds
3

Actions

Shares
Downloads
140
Comments
0
Likes
6

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. ERLANG THE WORLD IS PARALLEL. Picture: http://www.cs.purdue.edu/homes/jv/events/TiC06/pr.jpg
  • 2. 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
  • 3. 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
  • 4. Note and forgive that…   This is an Erlang beginner trying to give you an overview   I haven’t used Erlang for a while
  • 5. 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
  • 6. 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
  • 7. Therefore   Read the book
  • 8. You used Erlang to write what? http://www.cio.com/article/191000/You_Used_Ruby_to_Write_WHAT_ http://www.zedshaw.com/
  • 9. You used Erlang to write what?   Systems/Applications that are:   Concurrent   Parallel (SMP)   Distributed   Fault tolerant   Dynamically upgradable
  • 10. 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
  • 11. 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)
  • 12. OTP Source: http://www.ericsson.com/technology/opensource/erlang/index.shtml Picture: http://www.ericsson.com/technology/opensource/images/erlang.gif
  • 13. 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
  • 14. 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
  • 15. So don’t think imperative!   Don’t think   Java   C#   C   PHP   Etc.
  • 16. Think Function al!
  • 17. Don’t think Procedur al
  • 18. Think Recursi ve!
  • 19. Don’t think Loop y
  • 20. Let‘s get started Picture: http://www.wampower.com/images/wam%20pics/getting%20started/getting_started.jpg
  • 21. 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
  • 22. 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
  • 23. 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)
  • 24. 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}
  • 25. 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
  • 26. 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
  • 27. Anonymous functions (Funs) http://image.guardian.co.uk/sys-images/Arts/Arts_/Pictures/2007/08/10/laugh460.jpg
  • 28. 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
  • 29. 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
  • 30. 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
  • 31. 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
  • 32. 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
  • 33. 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   UsingTCP/IP Sockets   The Applications can run in a untrusted environment
  • 34. Hot Code Swapping Picture: http://www.firewebdesigns.com/images/fire_02.jpg
  • 35. 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
  • 36. 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
  • 37. 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
  • 38. 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.
  • 39. 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/
  • 40. 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/
  • 41. 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
  • 42. 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
  • 43. 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