Erlang made stupid simple for Ruby programmers

Update: This post has amazing traffic so it now has its own screencast

I have a strong gut feeling that Erlang is the next (current) big thing.

I started learning erlang with the very good and well written book by Joe Armstrong, Programming Erlang: Software for a Concurrent world . I am trying to keep a summary of what I am learning and so I started writing it as a little note. Doing so I noticed that I am able to squeeze a lot of pages into few lines and thought that someone else apart from me MIGHT also understand what I meant as I wrote it as if I was explaining Erlang to another Rubist. I hope I am right.

* I have tried to remain superficial and not to get into details in order to keep things as simple as possible to start with.

The list is here, I might also produce a small screen cast and part #2 for this in the coming future. Enjoy!

• end every sentence with a dot.


• you can write numbers with base declaration: BASE#NUMBER.
  example: 15 is like 10#15 or 16#f


• erlang has no variables, only constants.


• erlang's constants are being called variables.


• constants start with a capital letter:
  C = 5.
  CapitalLetter = 5.


• divide floats with "/"
  5 / 3 => 1.6667
  5.25 / 3 => 1.75


• divide integer with "div"
  5 div 3 => 1


• modulo = reminder = "rem"
  5 rem 3 => 2


• "string" is written with double-quotes


• atom = ruby :symbol is written as is (starts only with lowercase letter)
  johnny_walker


• 'something' acts different then "something" or symbol. still need to figure it out.


• kind of array = tuple
  defined with {}
  used broadly in erlang, also to replace complex data structures you would create a class for in ruby.
  NiceTuple = { 10, 45 }.
  NicerTuple = { 10, joe, 45, david }.


• {X,Y,Z} = {1,2,3}.
  X => 1
  Y => 2
  Z => 3
  like multiple assignment in ruby:
  x,y,z = 1,2,3
  it works just the same in these cases.


• {something,X} = {something,5}.
  x => 5
  BUT
  {something,X} = {something_else,5}.
  wont set X (!)
  "=" sets if left tuple structure fits right tuple structures in length and position of atoms/strings.
  {"gran torino",X} = {"gran torino",5}.
  X => 5


• err: {something,X,X,X} = {something,1,2,3}.


• {_,_,_,koko,5,X,_,_} = {i,dont,care,koko,5,123,whats,here}.
  X => 123


• arrays on steroids = lists
  defined with []
  [1,2,3,[4,5]]
  [i,ate,{a,tasty,cake}]


• SmallArray = [3,4].
  BigArray = [1,2|SmallArray].
  BigArray => [1,2,3,4].


• [First_element|All_the_rest] = Array.
  [First_element|All_the_rest] = [1,2,3,4,5].
  First_element => 1
  All_the_rest => [2,3,4,5]


• [First,Second,Third|All_the_rest] = Array.
  [First,Second,Third|All_the_rest] = [1,2,3,4,5,6].
  First => 1
  Second => 2
  Third => 3
  All_the_rest = [4,5,6].


• {X,Y,Z} = {1,koko,"loko"}.
  X => 1
  Y => koko
  Z => "loko"


• modules: Erlang's basic unit structure, comes in a file
  filename.erl
  erlang compiles it and then its called
  filename.beam


• the structure of a .erl file:
  -module(file_name).
  -export([function_name/1]).
  
  function_name(X) -> 0.
  ---------------------------
  this amazing module should then be called from the erl console with
  c(file_name)
  and then
  file_name:function_name(1) => 0
  file_name:function_name(koko) => 0
  file_name:function_name(whatever) => 0


• a more interesting function:
  -module(file_name).
  -export([function_name/1]).
  
  function_name(true) -> 'funny';
  function_name(false) -> 'not funny'.
  -----------------------------
  this function returns different values for "true" and for "false"


• one nicer example:
  -module(file_name).
  -export([fib/1]).
  
  fib(0) -> 0;
  fib(1) -> 1;
  fib(N) -> fib(N-1) + fib(N-2).

to be continued ...