Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.
Getting your feet wet
with Erlang
Come-on! The water’s warm!
First: A little background
What is Erlang?
“Erlang is a functional concurrency-oriented language with extremely low-
weigh...
First: A little background
Now in english…
● Functional before functional was “cool” (History)
● Designed from the ground-...
Getting it installed
Erlang Solutions provides all you need to get
started:
https://www.erlang-
solutions.com/downloads/do...
The Shell
$ erl
Erlang R16B03 (erts-5.10.4) [source] [smp:8:8] [async-threads:10] [kernel-poll:false]
Eshell V5.10.4 (abor...
Language Basics
● Data Types
● Operators
● Lists
● Pattern Matching
● Functions
● Modules
● Recursion (a.k.a. What? No loo...
Data Types
Numbers
● Integers -
o Base 10 by default
o Base can be specified using Base#value format
● Floats -
No magic h...
Data Types
Atoms -
Atoms are a key concept in Erlang. you will use then A LOT! And you will learn to appreciate them.
Atom...
Data Types
Atoms (continued) -
Caveat:
Atoms are really nice and a great way to send messages or represent constants. Howe...
Data Types
Strings -
Technically, strings are not an actual data type in Erlang. They are actually stored as a list of cha...
Data Types
Binaries and Bitstrings-
Erlang binaries are defined by <<value>>. It can be as simple as the following:
Erlang...
Data Types
Tuples -
Very straightforward representation of tuples. Tuples are used a lot in Erlang
and are particularly us...
Data Types
Booleans -
In Erlang, there are no true booleans. Instead, booleans are represented by the
atoms ‘true’ and ‘fa...
Comparison Operators
Erlang has all of the normal comparison operators you would expect to see
in any modern language. The...
Comparison Operators (cont’d)
Erlang also has all the normal logical operators such as and, or, xor, and not.
The boolean ...
Lists
Like with many other functional languages, lists are used to solve all kinds of
problems and are undoubtedly the mos...
Lists (cont’d)
You can also perform mathematical and comparison operations on strings.
In the above example, you can see t...
Pattern Matching
Pattern matching is one of the most powerful constructs within Erlang. As you
become familiar with it, yo...
Functions
Functions are first-class citizens in Erlang as in all functional languages.
You can also pass a function as an ...
Modules
Modules in Erlang are somewhat analogous to objects in OOP. However,
Erlang is NOT object-oriented! It may be bett...
Modules
Now you have a valid module. It doesn’t do anything. But, if you save that file, it
will compile. You won’t be abl...
Modules
Before we can do anything with this module, we need to make that function
publicly available. You do that with an ...
Recursion
One aspect of erlang that is often difficult to grasp for people coming from an
imperative background is the fac...
Processes
Erlang has been designed from the ground-up to be highly concurrent. A major
part of how it supports this level ...
Processes
Every process is assigned a Process Identifier (PID) that is used to
communicate between Erlang processes. You c...
Processes
You communicate between process via message passing. The send operator
in Erlang is the bang (“!”) symbol. And y...
Processes
Now you can easily pass messages between the two shell processes. In this
scenario, you will use a pattern of {p...
Processes
To receive messages in a process and handle them, you use what is called a
receive loop. Below is a simple examp...
Upcoming SlideShare
Loading in …5
×

Erlang kickstart

452 views

Published on

Quick guide to kickstart your journey into the wonderful world of Erlang.

Published in: Engineering
  • Be the first to comment

  • Be the first to like this

Erlang kickstart

  1. 1. Getting your feet wet with Erlang Come-on! The water’s warm!
  2. 2. First: A little background What is Erlang? “Erlang is a functional concurrency-oriented language with extremely low- weight user-space "processes", share-nothing message-passing semantics, built-in distribution, and a "crash and recover" philosophy proven by two decades of deployment on large soft-realtime production systems.” - Facebook Engineering
  3. 3. First: A little background Now in english… ● Functional before functional was “cool” (History) ● Designed from the ground-up to be highly concurrent with distribution provided by a share-nothing message passing architecture. ● Messages can easily be passed to modules running in different VM nodes or even on different servers. ● Processes are extremely lightweight (~512b vs. ~512MB for a java thread) ● Reliability takes top-priority. (Particularly when coupled with OTP) You are encouraged to “let it crash” and restart rather than attempt to deal with a failure. Given the stateless nature, this is typically not a problem. ● What does soft-real-time mean? In this case, as close to real-time as possible. (see 10.5 here)
  4. 4. Getting it installed Erlang Solutions provides all you need to get started: https://www.erlang- solutions.com/downloads/download-erlang-otp
  5. 5. The Shell $ erl Erlang R16B03 (erts-5.10.4) [source] [smp:8:8] [async-threads:10] [kernel-poll:false] Eshell V5.10.4 (abort with ^G) 1> 1 + 2. 3 2> 3 = 1 + 2. 3 3> 3 = 2 + 2. ** exception error: no match of right hand side value 4 4> Erlang = "Pure awesomeness!". "Pure awesomeness!" 5> Erlang. "Pure awesomeness!" 6> halt().
  6. 6. Language Basics ● Data Types ● Operators ● Lists ● Pattern Matching ● Functions ● Modules ● Recursion (a.k.a. What? No loops?) ● Processes (and PIDs) ● Example
  7. 7. Data Types Numbers ● Integers - o Base 10 by default o Base can be specified using Base#value format ● Floats - No magic here. 222.43 = 22.243e1. Erlang R16B03 (erts-5.10.4) [source] [smp:8:8] [async-threads:10] [kernel-poll:false] Eshell V5.10.4 (abort with ^G) 1> 15 = 2#1111 = 10#15 = 8#17 = 16#0F. 15
  8. 8. Data Types Atoms - Atoms are a key concept in Erlang. you will use then A LOT! And you will learn to appreciate them. Atoms are literals that must start will a lower-case letter. If you have a value that does not begin with a lower-case letter or contains characters other than alphanumeric, underscore (_) or an at symbol (@), you must enclose it in single quotes. Eshell V5.10.4 (abort with ^G) 1> is_atom(atom). true 2> is_atom(my_atom). true 3> is_atom(node1@my_machine). true 4> is_atom(‘node1@my_machine.erlang.org’). true
  9. 9. Data Types Atoms (continued) - Caveat: Atoms are really nice and a great way to send messages or represent constants. However there are pitfalls to using atoms for too many things: an atom is referred to in an "atom table" which consumes memory (4 bytes/atom in a 32-bit system, 8 bytes/atom in a 64-bit system). The atom table is not garbage collected, and so atoms will accumulate until the system tips over, either from memory usage or because 1048577 atoms were declared. This means atoms should not be generated dynamically for whatever reason; if your system has to be reliable and user input lets someone crash it at will by telling it to create atoms, you're in serious trouble. Atoms should be seen as tools for the developer because honestly, it's what they are. - Fred Hebert (Learn You Some Erlang)
  10. 10. Data Types Strings - Technically, strings are not an actual data type in Erlang. They are actually stored as a list of chars. Adjacent strings are automagically concatenated at compile time. Eshell V5.10.4 (abort with ^G) 1> "Hello" = [$H, $e, $l, $l, $o] = [72, 101, 108, 108, 111]. "Hello" 2> is_list("Hello"). true Eshell V5.10.4 (abort with ^G) 1> "Hello World" = "Hello " "World". "Hello World" 2> "Hello World" = "Hello " ++ "World". "Hello World"
  11. 11. Data Types Binaries and Bitstrings- Erlang binaries are defined by <<value>>. It can be as simple as the following: Erlang has many powerful abstractions for working with binaries. One basic example pattern matching: For digging deeper (and I highly recommend you do) check out the Erlang bit syntax docs. 3> <<"Erlang Rocks!">>. <<"Erlang Rocks!">> Eshell V5.10.4 (abort with ^G) 1> <<E,R,L,A,N,G,S,R2,O,C,K,S2,E2>> = <<"Erlang Rocks!">>. <<"Erlang Rocks!">>
  12. 12. Data Types Tuples - Very straightforward representation of tuples. Tuples are used a lot in Erlang and are particularly useful in pattern-matching. Eshell V5.10.4 (abort with ^G) 1> MyTuple = {mytuple, 4}. {mytuple,4} 2> is_tuple(MyTuple). true 3> AlsoATuple = {four_element_tuple, {1,2,3,4}}. {four_element_tuple,{1,2,3,4}} 4> is_tuple(AlsoATuple). true
  13. 13. Data Types Booleans - In Erlang, there are no true booleans. Instead, booleans are represented by the atoms ‘true’ and ‘false’. Other than that anomaly, there are a few unique characteristics as you’ll see.
  14. 14. Comparison Operators Erlang has all of the normal comparison operators you would expect to see in any modern language. There are a few anomalies as you will see. However, they are small and easy to adapt to. 1> 1 < 2. true 2> 5 > 12. false 3> 9 =< 9. true 4> 24 == 24.0. true 5> 24 =:= 24.0. false 6> 5 /= 5.00000. false 7> 5 =/= 5.00000. true Nothing unusual here. Wait. What? (Hint: The second of these compare type in addition to value.)
  15. 15. Comparison Operators (cont’d) Erlang also has all the normal logical operators such as and, or, xor, and not. The boolean operators and and or will always evaluate arguments on both sides of the operator. If you want to have the short-circuit operators (which will only evaluate the right-side argument if it needs to), use andalso and orelse. 1> true or false. true 2> true and false. false 3> true xor false. true 4> not false. true 5> not true. false 6> ((true or false) or (true and false)). true
  16. 16. Lists Like with many other functional languages, lists are used to solve all kinds of problems and are undoubtedly the most used data structure in Erlang. They are analogous to arrays in other, imperative, languages. The basic structure of a list is [Element1, Element2, ..., ElementN] and you can mix more than one type of data in it: 1> [1,2,3,4,5]. [1,2,3,4,5] 2> [2, false, "String", {myatom, [list, <<"of">>, [115,116,117,102,102]]}]. [2,false,"String",{myatom,[list,<<"of">>,"stuff"]}] Remember that strings are actually just lists of chars.
  17. 17. Lists (cont’d) You can also perform mathematical and comparison operations on strings. In the above example, you can see that lists are right associative (lines 3 and 4). Line 5 shows that when comparing lists, erlang starts from the first element and continues until the first differing element. In this case, element4 in the first list is greater than element4 in the second list. 1> [1,2,3,4,5] ++ [6,7]. [1,2,3,4,5,6,7] 2> [1,2,3,4,5] -- [2,3]. [1,4,5] 3> [1,2,3,4,5] -- [1,2,3] -- [3]. [3,4,5] 4> [1,2,3] ++ [4,5,6] -- [4,5]. [1,2,3,6] 5> [1,2,3,4,5] > [1,2,3,1,200]. true
  18. 18. Pattern Matching Pattern matching is one of the most powerful constructs within Erlang. As you become familiar with it, you come to love it. I promise! We will use pattern matching extensively over the remainder of this presentation, here are a few simple examples: 1> X = 2. 2 2> Y = X + 2. 4 3> {X, Y} = {2, 4}. {2,4} 4> {X, Y} = {1, 4}. ** exception error: no match of right hand side value {1,4} 5> GoodResult = {ok, "Success"}. {ok,"Success"} 6> BadResult = {error, "Not success"}. {error,"Not success"} 7> {ok, Value} = GoodResult. {ok,"Success"} 8> Value. "Success" 9> {ok, Value} = BadResult. ** exception error: no match of right hand side value {error,"Not success"}
  19. 19. Functions Functions are first-class citizens in Erlang as in all functional languages. You can also pass a function as an argument to another function. 1> Factor = 2. 2 2> Double = fun(X) -> Factor * X end. #Fun<erl_eval.6.80484245> 3> Double(2). 4 1> AddOne = fun(X) -> X + 1 end. #Fun<erl_eval.6.80484245> 2> Calculate = fun(Num, Fun) -> Fun(Num) end. #Fun<erl_eval.12.80484245> 3> 3> Calculate(4, AddOne). 5 4> Calculate(4, fun(X) -> math:pow(X, 2) end). 16.0 Anonymous function
  20. 20. Modules Modules in Erlang are somewhat analogous to objects in OOP. However, Erlang is NOT object-oriented! It may be better to say that modules are a grouping of, preferably, similar functions in a given file. In an Erlang module you can declare attributes (metadata describing the module itself such as its name, public functions, the author, etc.) and functions. To declare a module you must first give it a name. The name of the module MUST match the name of the physical file that contains it. Declaration of ./src/my_first_module.erl -module(my_first_module).
  21. 21. Modules Now you have a valid module. It doesn’t do anything. But, if you save that file, it will compile. You won’t be able to do anything with it. You first need to add some functions. Let’s add a simple function. This doesn’t really do anything exciting. However, it does display how you define a method in erlang. First comes the method name. method names follow the same general rules as atoms. (They must start with a lowercase letter and only contain alphanumeric characters and underscores.) say_hello() -> io:format("Hello!").
  22. 22. Modules Before we can do anything with this module, we need to make that function publicly available. You do that with an export attribute. The signature of the export is “-export([method_name/arity])” Now you have exported that function and it can be used by other modules. ● Calling a module takes the form module_name:function_name(Arguments) -export([say_hello/0]). 1> c(my_first_module). {ok,my_first_module} 2> my_first_module:say_hello(). Hello! ok
  23. 23. Recursion One aspect of erlang that is often difficult to grasp for people coming from an imperative background is the fact that there is no real concept of a loop. In it’s place, you use recursive functions. So, instead of using something like this: You would instead use a recursive function that takes the “head” element of the list passed-in and prints it: (Note that the above also introduces the concept of pattern matching on lists.) for (int i = 0; i < list.length; i++) { System.out.println(list[i]); } print_my_list([]) -> ok. print_my_list([H|T]) -> io:format("~p~n") [H]), print_my_list(T).
  24. 24. Processes Erlang has been designed from the ground-up to be highly concurrent. A major part of how it supports this level of concurrency is the fact that all running/loaded modules are individual processes. you can think abstractly of a process like a thread in other languages. However, erlang processes are designed to be short-lived and spun-up and torn-down regularly to perform isolated processes. As such, Erlang processes have been designed to be much more lightweight than threads in other languages (~512b vs. ~512MB for a java thread). It is not unusual to see an Erlang application running 10’s of thousands of processes simultaneously and still maintaining a relatively small memory footprint.
  25. 25. Processes Every process is assigned a Process Identifier (PID) that is used to communicate between Erlang processes. You can get the PID of the current process with the self() function. That three section binary is the PID. There is an excellent description of of how they are constructed with links to the source that creates them here. (meetup1@dnvcoml-1cydkq4)1> self(). <0.38.0>
  26. 26. Processes You communicate between process via message passing. The send operator in Erlang is the bang (“!”) symbol. And you send a message by specifying the PID you want to send the message to followed by the bang then the message you want to pass. Now we should get this process communicating to another. To do this, I will create another shell called meetup2. And, to make things cleaner, I will register both shell processes with the name of shell. (meetup1@dnvcoml-1cydkq4)2> self() ! "Hello to me!". "Hello to me!" (meetup1@dnvcoml-1cydkq4)3> flush(). Shell got "Hello to me!" ok (meetup2@dnvcoml-1cydkq4)1> register(shell, self()).
  27. 27. Processes Now you can easily pass messages between the two shell processes. In this scenario, you will use a pattern of {process, node} ! message. (meetup1@dnvcoml-1cydkq4)2> {shell, 'meetup2@dnvcoml-1cydkq4'} ! "Hello meetup2!". "Hello meetup2!" (meetup2@dnvcoml-1cydkq4)2> flush(). Shell got "Hello meetup2!"
  28. 28. Processes To receive messages in a process and handle them, you use what is called a receive loop. Below is a simple example. Now, if I send a message to meetup2 from meetup1, I will get a response back. (meetup2@dnvcoml-1cydkq4)1> receive (meetup2@dnvcoml-1cydkq4)1> {hello, PID} -> PID ! "Right back at ya!"; (meetup2@dnvcoml-1cydkq4)1> {goodbye, PID} -> PID ! "Goodbye! Sorry to see you go!"; (meetup2@dnvcoml-1cydkq4)1> _ -> ok (meetup2@dnvcoml-1cydkq4)1> end. (meetup1@dnvcoml-1cydkq4)3> {shell, 'meetup2@dnvcoml-1cydkq4'} ! {hello, self()}. {hello,<0.38.0>} (meetup1@dnvcoml-1cydkq4)4> flush(). Shell got "Right back at ya!" (meetup1@dnvcoml-1cydkq4)6> flush(). Shell got "Goodbye! Sorry to see you go!"

×