A basic quick intro to elixir for ruby programmers

1. elixir
for Rubyists

2. The lovechild of ruby &
erlang
+
=

3. What’s similar

4. Syntax
defmodule Underscore.Enum do!
! def pull(list, other) do!
! ! Enum.reject(list, fn(item)-> item in other end)!
! end!
end!

5. Meta-Programming
defmodule MyMacro do!
defmacro unless(clause, options) do!
quote do: if(!unquote(clause), unquote(options))!
end!
end!

6. And other fun stuff
•
Huge, expressive standard lib
•
Heredocs, Multiline Strings, String Interpolation
•
Sigils(i.e %w/%c etc)
•
Great documentation
•
ITS FUN(C) TO WORK WITH

7. Whats different

8. Functional
•
Functions are first level citizens
iex> square = fn x -> x * x end!
!
#Function<6.17052888 in :erl_eval.expr/5>!
iex> Enum.map(1..10, square)!
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]!
!
•
List Comprehensions
iex> lc x inlist [1, 2], y inlist [3, 4], do: x * y!
[3, 4, 6, 8]!

9. Immutable
iex>
[:a,
iex>
[:a,
iex>
[:a,
iex>
[:a,
iex>
[:a,
list = [:a, :b, :c]!
:b, :c]!
List.delete(list, :b)!
:c]!
list!
:b, :c]!
list = List.delete(list, :b)!
:c]!
list!
:c]!

10. Pattern matching
iex> {[head | tail], {:atom, msg}} = !
! ! ! ! {[1, 2, 3], {:atom, "PATTERN MATCHING FTW!"}} !
{[1, 2, 3], {:atom, "PATTERN MATCHING FTW!"}}!
iex> head!
1!
iex> tail!
[2, 3]!
iex> msg!
"PATTERN MATCHING FTW!"!

11. Pattern matching functions are
amazing
defmodule MyEnum do!
def sum([]), do: 0!
def sum([head | tail]), do: head + sum(tail)!
end!

12. Whats AMAZING

13. The pipe operator
We all wrote code like this from time to time:
people
!
orders
tax
filing
!
=
=
=
=
DB.find_customers!
Orders.for_customers(people)!
sales_tax(orders, 2013)!
prepare_filing(tax)!
Or worse, this:
filing =
prepare_filing(sales_tax(Orders.for
_customers(DB.find_customers)))!

14. Ta daa
filing = DB.find_customers!
! |> Orders.for_customers!
! |> sales_tax(2013)!
! |> prepare_filing!

15. Function capture
Enum.map [1,2,3], fn(x) -> x * x end!
!
!
!
Enum.map [1,2,3], &(&1 * &1)!

16. Guard clauses
defmodule Factorial do!
def of(0), do: 1!
def of(n) when n > 0 do!
n * of(n-1)!
end!
end!

17. Optional(!) type checking
@spec add(integer, integer), do: integer!
def add(a, b), do: a + b!

18. Concurrency

19. Actor based
defmodule Greeter do!
def greet do !
receive do !
{:english, name} -> !
IO.puts "Hello, #{name}."!
greet!
{:chinese, name} -> !
IO.puts "你½ 好¥½, #{name}."!
greet!
{:spanish, name} -> !
IO.puts "¡Hola!, #{name}."!
greet!
:exit -> !
IO.puts "Bye bye!"!
_ -> !
IO.puts "I don't understand ... but Hello anyway!"!
greet!
end!
end!
end

20. !
iex> greeter = spawn(Greeter, :greet, [])!
#PID<0.52.0>!
!
iex> greeter <- {:english, 'Amy'}!
Hello, Amy.!
{:english, ‘Amy'}!
!
iex> greeter <- {:chinese, 'Ben'}!
{:chinese, 'Ben'}!
你½ 好¥½, Ben.!
!
iex> greeter <- {:spanish, 'Charlie'}!
{:spanish, 'Charlie'}!
¡Hola!, Charlie.!
!
iex(31)> greeter <- {:klingon, 'David'}!
I don't understand ... but Hello anyway!!

21. Few notes about actors
•
They’re fast & lightweight - you can have 10,000 of
them on a tiny machine.
•
The queue is managed by the VM
•
Support hot-swapping

22. Native support for multi
machine distribution
•
on
~>
on
~>
!
Actors can be on a local or remote VM, and it’s
transparent to you!
machine1!
iex --name node1@machine1.com --cookie a_cookie_string!
machine2!
iex --name node2@machine2.com --cookie a_cookie_string!
iex(node1@machine1.com)1> Node.connect :"node2@machine2.com"!
true!
!
iex(node1@machine1.com)2> print_node_name = fn -> IO.puts Node.self end!
#Function<erl_eval.20.80484245>!
!
iex(node1@machine1.com)3> Node.spawn(:"node2@machine2.com", print_node_name)!
node2@machine2.com!
#PID<7789.49.0> !

23. The OTP
Open Telecom Platform - but nobody cares

24. Reliability
•
Linked processes/Supervisor tree
•
Failover nodes
•
Hot code reload
•
20 years of battle-tested code, it’s VERY hard to break.
•
used by a very huge scale applications:
•
Facebook Messages/ WhatsApp
•
Riak/ CouchDB/ RabbitMQ

25. Summery
•
Functional and fun
•
FAST
•
Low/high level language
•
Mature VM/young language
•
Scalable