Intro To Erlang

Introduction to Erlang Erlang is a functional, concurrency-oriented, distributive, fault-tolerant programming language. 1

Philosophy of Erlang “Erlang was designed for writing concurrent programs that quot;run foreverquot;.” - Joe Armstrong Let it fail. Have another process deal with it. Fault tolerance requires at least *two* computers. 2

Erlang Mindset Lots of little tasks Tons of processes Each process does a task very well Ant Colony Ants are processes sending messages to each other 3

Why Erlang? 4

Erlang makes hard things easier. 5

Concurrency 6

Spawning Processes 8

F = fun() -> io:format(“hi”) end, spawn(F). >> hi<0.34.0> 9

spawn(io, format, [“hi”]). 10

Message Passing 11

Pid ! Message Pid ! {do_task, run_home} Pid ! 2 13

receive ... end receive Pattern1 [when Guard1] -> Expressions1; Pattern2 [when Guard2] -> Expressions2 end. 14

Messages are contained in a process’s inbox. receive _ -> ok end. 15

Fault Tolerance 16

which is why erlang was designed to be.... 19

Distributive 20

Pid ! Message where Pid exists on another node. 22

Erlang Nodes Can only talk if the erlang ‘cookie’ is the same Can exist on the same machine or different machines Does have overhead, isn’t free Can have ‘C’ nodes (+ other node types that speak erlang) Communicate via Global Name Registry, Speciﬁc Pids, or by Node name 23

The Basics 24

Erlang is Functional 25

Periods, Commas, Semicolons Oh My! People think Erlang’s syntax is ugly. It’s actually very logical. 26

Periods ( . ) end everything except when Semicolons ( ; ) end clauses and Commas ( , ) separate expressions. 27

calculate_area({square, Size}) -> Size * Size; calculate_area({circle, Radius}) -> Pi = 3.14, Pi * Radius * Radius; calculate_area(_Unknown) -> ok. 28

case Expression of {do_task, run_home} -> Home = 123, spawn(run, home, [Home]); _ -> ok end. 29

Data Types 30

Integer - however big you can imagine Floats Atoms - similar to a ruby symbol, they are used to represent non-numerical constants (true, false, ok, error) Tuple - Fixed length collection of items ({one, two, three} or {one, two} etc) Lists - Stores a variable number of things ([1, 2, {one, two}, $a]) 31

Missing Links... 32

Strings - A string is just a list of integers in erlang. Booleans - Use atoms (true, false) Hash - Property List ( [tuple()] ) shown later 33

Pattern Matching Once you pattern match, variable assigning feels dirty. 34

1 = 1 ( ok ) 1 = 2 ( error thrown bad_match ) Value = {2, 4}, {Width, Height} = {2, 4} ( ok ) [Head|Tail] = [1,2,3,4] ( ok ) 35

Variable Binding or restricting inﬁnite possibilities. 36

An unbound variable can be anything it needs to be (inﬁnite possibilities) A. 37

Pattern matching an unbound variable is like restricting what it can be. A = 1. A = 2. (error bad_match) 38

Tuples Single entity that holds a collection of items. 39

{1, 2, 3}. {one, two}. {user_id, 2, user_name, “asceth”}. 40

Lists Variable sized container of items. 41

List = [1, 2, 3], NewList = List ++ [4, 5, 6]. >> [1, 2, 3, 4, 5, 6] [Head|Tail] = NewList. >> Head -> 1 >> Tail -> [2, 3, 4, 5, 6] 42

[tuple()] Property Lists or semi-hashes. 43

PList = [{key, value}, {key1, value1}]. case lists:keysearch(key, 1, PList) of false -> error; {value, {Key, Value}} -> Value end. 44

keydelete - deletes tuple with speciﬁed key in list of tuples and returns new list keymap - returns list of tuples where Nth element is replaced be speciﬁed fun keymember - tests for existence of key keymerge - combines two tuples with tuple1 taking priority ukeymerge, ukeysort - like keymerge but removes duplicates in tuple2 45

Functions Pattern matching, Function Arities & more 46

Functions with the same name can exist Functions with the same name and different arity can exist Erlang tells you if a function cannot be called due to order of deﬁnement Function order is very important 47

contains(Key, []) -> false; contains(Key, List) -> lists:any(fun(X) -> Key == X end, List). contains(1, [1, 2, 3]). true contains({home, 123}, [{apartment, 333}, {house, 000}]). false 48

Anonymous 49

contains(Key, []) -> false; contains(Key, List) -> lists:any(fun(X) -> Key == X end, List). F = fun(X, Y) -> X1 = X * 2, Y1 = Y * X, X1 + Y1 end, F(2, 2). >> 12 50

Looping Tail recursion makes looping good again. 51

print([]) -> ok; print([H|T]) -> io:format(“~p~n”, [H]), print(T). 52

Conditionals If’s are okay, cases are cooler. 53

if A == 5 -> do_something(); true -> do_something_else() end. 54

case A of 0 -> first(); 2 -> second(); _ -> something() end. 55

Resources http://www.erlang.org Technorati 56

Questions? 58

http://www.seerhut.cn	111
http://colaruby.org	57
http://www.slideshare.net	24
http://colaruby.com	10
http://blog.seerhut.cn	9
http://cache.baidu.com	3
http://webcache.googleusercontent.com	2
http://www.colaruby.org	2
http://www.seerhut.cn} {214740178\|\|\|pingback	1
http://www.seerhut.cn} {229810493\|\|\|pingback	1
http://74.6.239.84	1
http://translate.googleusercontent.com	1

Intro To Erlang

by asceth on Dec 04, 2008

Accessibility

Categories

Tags

Upload Details

Usage Rights

12 Embeds 222

Statistics

Intro To Erlang — Presentation Transcript