• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Introduction to Erlang
 

Introduction to Erlang

on

  • 1,454 views

Suitable for an audience with little exposure to functional programming. Concurrency and handling errors in Erlang are skipped due to time

Suitable for an audience with little exposure to functional programming. Concurrency and handling errors in Erlang are skipped due to time

Statistics

Views

Total Views
1,454
Views on SlideShare
1,449
Embed Views
5

Actions

Likes
0
Downloads
17
Comments
0

2 Embeds 5

https://www.linkedin.com 3
http://www.linkedin.com 2

Accessibility

Upload Details

Uploaded via as Microsoft PowerPoint

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

    Introduction to Erlang Introduction to Erlang Presentation Transcript

    • Erlang – Quick Intro
      Brought to you by Raymond Tay
    • Erlang?
      Small language designed more than 20 years ago by Joe Armstrong, Robert Virding and Mike Williams of Ericsson’s CS Lab.
      Functional Language.
      Lightweight concurrency model (aka Actors). Yes, Scalahas a Actors model where they share similar syntax and machinery.
      Great for soft real-time systems. E.g. Second Life’s chat service
      Not good for number crunching. There are better tools for that e.g. SciPyNumPy
    • Yah yah yah…WHO actually uses Erlang?
      Amazon uses Erlang to implement SimpleDB as part of its EC2 services
      Facebook uses Erlang to power its backend chat service for its 100 million active users
      Ericsson uses Erlang to support its GPRS and 3G mobile networks
      T-Mobile uses Erlang in its SMS and authentication systems
    • So, what are the benefits of Erlang?
      Easy to learn, easy to use. Expressing distributing computing is easier
      Garbage collection is implemented on a per process basis
      An process in Erlang is light-weight i.e. not a OS process. Each pair of processes communicate by passing messages
      Designed to operate behind firewalls. Think private compute cloud
    • Let’s learn how Erlang does it
      Numbers
      Variables (they’re not variable)
      Atoms
      Boolean Algebra and Comparison Operators
      Tuples
      Lists (and comprehensions)
      Modules in Erlang
    • There’s more…
      High-order functions and Lambdas
      Errors and catching them (We don’t have time for this)
      Concurrency in Erlang and Actors etc (We don’t have time for this too)
      Finally we’ll end with a demonstration
    • Working with Erlang
      In FP, statements do not exist only expressions. Expressions always return a result and more often than not, have no side effects at all; statements (depending on the lang) may / may not return a result but always have side effects.
      Expressions, in Erlang, have to be terminated with a period followed by whitespace (n, )
      E.g expression involving numbers
      2 + 5.
      5 / 2. (same as 5 div 2.)
      5 rem 2.
      -50 * (100 – 499). (Erlang understands the typical math operator precedences)
      2#101 (same as the decimal number 5 only expressed in binary i.e. base 2)
      16#cafebabe (do you know what this magic number is expressed in base 16?)
    • Variables in Erlang (seriously???)
      No such thing as a variable variable
      In Erlang, creating a variable and associating with a value is termed bounding. You cannot change the value once bounded.
      One = 1.
      One = 2. (Will not succeed)
      Two = 2.
      Two = One + One. (Will succeed)
      _ = 999999999 (Will always succeed. ‘_’ is the i-don’t-care-variable)
      The ‘=‘ acts as an assignment and pattern matching operator. Pattern matching occurs with/without the ‘=‘. More later.
    • Atoms (Like the physics term but not like it)
      In physics of the 1920s, atoms were the smallest things known to man. Today, there are units smaller than the atom like hadrons, quarks. In Erlang, an atom is a literal.
      hello. (Typing Hello. means to extract the value of Hello)
      ‘Hello there’. (anything in quotes is an atom)
      ‘_this_is_a_#really_!long_@string’.
    • Boolean Algebra, Operators
      In Erlang, the atom true is Truth whereas false is Falsehood.
      You can use =:= and =/= for comparing equality and inquality
      You can use == and /= for comparing equality and inequality if you don’t care about exactness / precisions
      5 =:= 5. (will return true)
      5 == 5. (will return true)
      5 =:= 5.0. (will return false)
      5 == 5.0. (will return true)
    • Tuples
      They allow you to aggregate values to form some sort of data structure.
      X = 10, Y = 4.
      Point = {X, Y}. (Tuple is created)
      {MyX, _} = Point. (Pattern matching at play. MyX will get the value 10)
      {_, _, _} = Point. (will fail and erlang will complain RHS don’t match LHS)
    • Lists
      In FP, lists are completely indispensable. Same here
      You can create lists, obviously. You can concat, intersect them. You can retrieve the head or tail of a list via ‘hd’ and ‘tl’ commands in the ‘erlang’ module
      MyList = [1,2,3,4,5].
      MyList ++ [7,8] - - [1,2,3,4,5,6,78]. (equivalent to (MyList ++ ([7,8] - - [1,2,3,4,5,6,7,8])) )
      hd( [1,2] ). (will return 1 and take note its not a list)
      tl([1,2]). (will return [2] which is a list)
    • List Comprehension
      In other languages, its called a for-comprehension. Let’s look at code examples
      [2 * N | | N <- [1,2,3]]. (returns [2,4,6])
      [X | | X <- [1,2,3,4,5,6], X rem 2 =:= 0]. (returns [2,4,6] )
      Let’s look at a more complex example (taken from sg.finance.yahoo.com)
      [ {Quote,Price} | | {Quote, Price} <- [ {e3s, 0.4}, {g13.si, 1.66}, {'5im.si',0.22}, {e5h.si, 0.64} ], Price > 0.5]. (returns [{'g13.si',1.66},{'e5h.si',0.64}])
      Nested-for-loops (Ugly word in Erlang, but u get the meaning)
      [ {X, Y} | | X <- [1,2], Y <- [3,4]]. (returns [{1,3}, {1,4}, {2,3}, {2,4}])
    • How to avoid clustering all code in a single file?
      You need modules.
      You need to declare your module’s name, attributes, what functions are exported
    • Compiling and using your modules
      There are a couple of methods to do this but for the sake of brevity, here’s the simplest
    • Functions and Lambdas
      Functions are easy to write in Erlang. You don’t need to say ‘def’, ‘function’ or give any access specifier like ‘public’, ‘protected’ any of that nonsense.
      Here’s an example of a Mapper function.
      map(_, []) -> [];
      map(F, [H|T]) -> [F(H) | map(F, T)].
      Another example of a Folder function
      fold(F, Start, []) -> Start;
      fold(F, Start, [H|T]) -> fold(F, F(H, Start), T).
      A lambda function is simply a nameless function and sometimes called an anonymous function. They can do pretty much anything except recursion.
      The form is like this:
      fun (Args1) -> Expression1, … , Expression N ;
      (Args2) -> Expression1, … , Expression N;
      end.
    • Lambdas
    • More Lambdas…
    • Demo
      This is a demo of a sorting algorithm I wrote in 2007 as it illustrates most of the concepts we talked about.