• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Erlang, an overview
 

Erlang, an overview

on

  • 5,408 views

An overview presentation about Erlang, the concurrent programming language

An overview presentation about Erlang, the concurrent programming language

Statistics

Views

Total Views
5,408
Views on SlideShare
5,135
Embed Views
273

Actions

Likes
6
Downloads
138
Comments
0

5 Embeds 273

http://erlangmmo.blogspot.com 149
http://www.huesler-informatik.ch 113
http://www.slideshare.net 9
http://translate.googleusercontent.com 1
http://localhost 1

Accessibility

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Erlang, an overview Erlang, an overview Presentation Transcript

    • 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 Function al!
    • Don’t think Procedur al
    • Think Recursi ve!
    • Don’t think Loop y
    • 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   UsingTCP/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